dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467
 468 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 469
 470 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 471 #include <dali/devel-api/adaptor-framework/image-loading.h>
 472
 473 #include <dali/public-api/events/mouse-button.h>
 474
 475 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 476
 477
 478 // add here SWIG version check
 479
 480 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 481 // disable Swig-dependent warnings
 482
 483 // 'identifier1' has C-linkage specified,
 484 // but returns UDT 'identifier2' which is incompatible with C
 485 #pragma warning(disable: 4190)
 486
 487 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 488 #pragma warning(disable: 4800)
 489
 490 // debug info too long etc etc
 491 #pragma warning(disable: 4786)
 492 #endif
 493
 494
 495 #include <stdexcept>
 496
 497
 498 #include <string>
 499
 500
 501 #include <vector>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <map>
 507 #include <algorithm>
 508 #include <stdexcept>
 509
 510
 511 #include <utility>
 512
 513
 514 typedef float floatp;
 515
 516 SWIGINTERN floatp *new_floatp(){
 517   return new float();
 518 }
 519 SWIGINTERN void delete_floatp(floatp *self){
 520   if (self) delete self;
 521 }
 522 SWIGINTERN void floatp_assign(floatp *self,float value){
 523   *self = value;
 524 }
 525 SWIGINTERN float floatp_value(floatp *self){
 526   return *self;
 527 }
 528 SWIGINTERN float *floatp_cast(floatp *self){
 529   return self;
 530 }
 531 SWIGINTERN floatp *floatp_frompointer(float *t){
 532   return (floatp *) t;
 533 }
 534
 535 typedef int intp;
 536
 537 SWIGINTERN intp *new_intp(){
 538   return new int();
 539 }
 540 SWIGINTERN void delete_intp(intp *self){
 541   if (self) delete self;
 542 }
 543 SWIGINTERN void intp_assign(intp *self,int value){
 544   *self = value;
 545 }
 546 SWIGINTERN int intp_value(intp *self){
 547   return *self;
 548 }
 549 SWIGINTERN int *intp_cast(intp *self){
 550   return self;
 551 }
 552 SWIGINTERN intp *intp_frompointer(int *t){
 553   return (intp *) t;
 554 }
 555
 556 typedef double doublep;
 557
 558 SWIGINTERN doublep *new_doublep(){
 559   return new double();
 560 }
 561 SWIGINTERN void delete_doublep(doublep *self){
 562   if (self) delete self;
 563 }
 564 SWIGINTERN void doublep_assign(doublep *self,double value){
 565   *self = value;
 566 }
 567 SWIGINTERN double doublep_value(doublep *self){
 568   return *self;
 569 }
 570 SWIGINTERN double *doublep_cast(doublep *self){
 571   return self;
 572 }
 573 SWIGINTERN doublep *doublep_frompointer(double *t){
 574   return (doublep *) t;
 575 }
 576
 577 typedef unsigned int uintp;
 578
 579 SWIGINTERN uintp *new_uintp(){
 580   return new unsigned int();
 581 }
 582 SWIGINTERN void delete_uintp(uintp *self){
 583   if (self) delete self;
 584 }
 585 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 586   *self = value;
 587 }
 588 SWIGINTERN unsigned int uintp_value(uintp *self){
 589   return *self;
 590 }
 591 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 592   return self;
 593 }
 594 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 595   return (uintp *) t;
 596 }
 597
 598 typedef unsigned short ushortp;
 599
 600 SWIGINTERN ushortp *new_ushortp(){
 601   return new unsigned short();
 602 }
 603 SWIGINTERN void delete_ushortp(ushortp *self){
 604   if (self) delete self;
 605 }
 606 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 607   *self = value;
 608 }
 609 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 610   return *self;
 611 }
 612 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 613   return self;
 614 }
 615 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 616   return (ushortp *) t;
 617 }
 618
 619 unsigned int int_to_uint(int x) {
 620    return (unsigned int) x;
 621 }
 622
 623
 624 using namespace Dali;
 625 using namespace Dali::Toolkit;
 626
 627 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 628 {
 629   bool result = false;
 630   try
 631   {
 632     // C++ code. DALi uses Handle <-> Body design pattern.
 633     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 634     // Handles in DALi can be converted into a boolean type
 635     // to check if the handle has a valid body attached to it.
 636     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 637     if( *self )
 638     {
 639       result = true;
 640     }
 641     else
 642     {
 643       result = false;
 644     }
 645   }
 646   catch (std::out_of_range& e)
 647   {
 648     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 649     return 0;
 650   }
 651   catch (std::exception& e)
 652   {
 653     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 654     return 0;
 655   }
 656   catch (DaliException e)
 657   {
 658     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 659     return 0;
 660   }
 661   catch (...)
 662   {
 663     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 664     return 0;
 665   }
 666   return result;
 667 }
 668
 669 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 670 {
 671   bool result = false;
 672   try
 673   {
 674     // C++ code. Check if two handles reference the same implemtion
 675     if( *self == rhs)
 676     {
 677       result = true;
 678     }
 679     else
 680     {
 681       result = false;
 682     }
 683   }
 684   catch (std::out_of_range& e)
 685   {
 686     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 687     return 0;
 688   }
 689   catch (std::exception& e)
 690   {
 691     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 692     return 0;
 693   }
 694   catch (DaliException e)
 695   {
 696     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 697     return 0;
 698   }
 699   catch (...)
 700   {
 701     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 702     return 0;
 703   }
 704   return result;
 705 }
 706
 707
 708 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 709      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 710    }
 711 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){
 712      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 713    }
 714 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 715         std::vector< Dali::TouchPoint >* pv = 0;
 716         if (capacity >= 0) {
 717           pv = new std::vector< Dali::TouchPoint >();
 718           pv->reserve(capacity);
 719        } else {
 720           throw std::out_of_range("capacity");
 721        }
 722        return pv;
 723       }
 724 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(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 Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 737         if (index>=0 && index<(int)self->size())
 738           (*self)[index] = val;
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 743         self->insert(self->end(), values.begin(), values.end());
 744       }
 745 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 746         if (index < 0)
 747           throw std::out_of_range("index");
 748         if (count < 0)
 749           throw std::out_of_range("count");
 750         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 751           throw std::invalid_argument("invalid range");
 752         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 755         if (index>=0 && index<(int)self->size()+1)
 756           self->insert(self->begin()+index, x);
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, values.begin(), values.end());
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 767         if (index>=0 && index<(int)self->size())
 768           self->erase(self->begin() + index);
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 773         if (index < 0)
 774           throw std::out_of_range("index");
 775         if (count < 0)
 776           throw std::out_of_range("count");
 777         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 778           throw std::invalid_argument("invalid range");
 779         self->erase(self->begin()+index, self->begin()+index+count);
 780       }
 781 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 782         if (count < 0)
 783           throw std::out_of_range("count");
 784         return new std::vector< Dali::TouchPoint >(count, value);
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 787         std::reverse(self->begin(), self->end());
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 790         if (index < 0)
 791           throw std::out_of_range("index");
 792         if (count < 0)
 793           throw std::out_of_range("count");
 794         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 795           throw std::invalid_argument("invalid range");
 796         std::reverse(self->begin()+index, self->begin()+index+count);
 797       }
 798 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 799         if (index < 0)
 800           throw std::out_of_range("index");
 801         if (index+values.size() > self->size())
 802           throw std::out_of_range("index");
 803         std::copy(values.begin(), values.end(), self->begin()+index);
 804       }
 805 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 806          return self->Empty();
 807       }
 808 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 809         return self->GetConnectionCount();
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 812           self->Connect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Disconnect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 818           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 819 /*@SWIG@*/ self->Emit( arg );
 820       }
 821 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 822          return self->Empty();
 823       }
 824 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825         return self->GetConnectionCount();
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 828           self->Connect( func );
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Disconnect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 834           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 835 /*@SWIG@*/ self->Emit( arg );
 836       }
 837 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 838          return self->Empty();
 839       }
 840 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){
 841         return self->GetConnectionCount();
 842       }
 843 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 *)){
 844           self->Connect( func );
 845       }
 846 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 *)){
 847           self->Disconnect( func );
 848       }
 849 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){
 850           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 851 /*@SWIG@*/ self->Emit( arg );
 852       }
 853 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 854          return self->Empty();
 855       }
 856 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857         return self->GetConnectionCount();
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 860           self->Connect( func );
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Disconnect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 866           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 867 /*@SWIG@*/ self->Emit( arg );
 868       }
 869 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 870          return self->Empty();
 871       }
 872 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 873         return self->GetConnectionCount();
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 876           self->Connect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Disconnect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 882           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 883 /*@SWIG@*/ self->Emit( arg );
 884       }
 885 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){
 886          return self->Empty();
 887       }
 888 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){
 889         return self->GetConnectionCount();
 890       }
 891 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 &)){
 892         self->Connect( func );
 893       }
 894 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 &)){
 895         self->Disconnect( func );
 896       }
 897 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){
 898         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 899 /*@SWIG@*/ self->Emit( arg1, arg2 );
 900       }
 901 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){
 902          return self->Empty();
 903       }
 904 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){
 905         return self->GetConnectionCount();
 906       }
 907 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 &)){
 908         self->Connect( func );
 909       }
 910 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 &)){
 911         self->Disconnect( func );
 912       }
 913 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){
 914         return self->Emit( arg1, arg2 );
 915       }
 916 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){
 917          return self->Empty();
 918       }
 919 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){
 920         return self->GetConnectionCount();
 921       }
 922 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 &)){
 923         self->Connect( func );
 924       }
 925 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 &)){
 926         self->Disconnect( func );
 927       }
 928 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){
 929         return self->Emit( arg1, arg2 );
 930       }
 931 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){
 932          return self->Empty();
 933       }
 934 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){
 935         return self->GetConnectionCount();
 936       }
 937 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 &)){
 938         self->Connect( func );
 939       }
 940 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 &)){
 941         self->Disconnect( func );
 942       }
 943 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){
 944         return self->Emit( arg1, arg2 );
 945       }
 946 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 947          return self->Empty();
 948       }
 949 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 950         return self->GetConnectionCount();
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 953           self->Connect( func );
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Disconnect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 959           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 960 /*@SWIG@*/ self->Emit( arg );
 961       }
 962 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 963          return self->Empty();
 964       }
 965 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){
 966         return self->GetConnectionCount();
 967       }
 968 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 &)){
 969           self->Connect( func );
 970       }
 971 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 &)){
 972           self->Disconnect( func );
 973       }
 974 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){
 975           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 976 /*@SWIG@*/ self->Emit( arg );
 977       }
 978 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 979          return self->Empty();
 980       }
 981 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){
 982         return self->GetConnectionCount();
 983       }
 984 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 &)){
 985           self->Connect( func );
 986       }
 987 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 &)){
 988           self->Disconnect( func );
 989       }
 990 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){
 991           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 992 /*@SWIG@*/ self->Emit( arg );
 993       }
 994 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 995          return self->Empty();
 996       }
 997 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){
 998         return self->GetConnectionCount();
 999       }
1000 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 &)){
1001           self->Connect( func );
1002       }
1003 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 &)){
1004           self->Disconnect( func );
1005       }
1006 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){
1007           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1008 /*@SWIG@*/ self->Emit( arg );
1009       }
1010 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){
1011          return self->Empty();
1012       }
1013 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){
1014         return self->GetConnectionCount();
1015       }
1016 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 &)){
1017         self->Connect( func );
1018       }
1019 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 &)){
1020         self->Disconnect( func );
1021       }
1022 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){
1023         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1024 /*@SWIG@*/ self->Emit( arg1, arg2 );
1025       }
1026 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){
1027          return self->Empty();
1028       }
1029 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){
1030         return self->GetConnectionCount();
1031       }
1032 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 &)){
1033         self->Connect( func );
1034       }
1035 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 &)){
1036         self->Disconnect( func );
1037       }
1038 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){
1039         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1040 /*@SWIG@*/ self->Emit( arg1, arg2 );
1041       }
1042 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){
1043          return self->Empty();
1044       }
1045 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){
1046         return self->GetConnectionCount();
1047       }
1048 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 &)){
1049         self->Connect( func );
1050       }
1051 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 &)){
1052         self->Disconnect( func );
1053       }
1054 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){
1055         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1056 /*@SWIG@*/ self->Emit( arg1, arg2 );
1057       }
1058 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1059          return self->Empty();
1060       }
1061 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062         return self->GetConnectionCount();
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1065           self->Connect( func );
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Disconnect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1071           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1072 /*@SWIG@*/ self->Emit( arg );
1073       }
1074 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){
1075          return self->Empty();
1076       }
1077 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){
1078         return self->GetConnectionCount();
1079       }
1080 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)){
1081           return self->Connect( func );
1082       }
1083 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)){
1084           self->Disconnect( func );
1085       }
1086 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){
1087           self->Emit( arg1, arg3 );
1088       }
1089 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){
1090          return self->Empty();
1091       }
1092 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){
1093         return self->GetConnectionCount();
1094       }
1095 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)){
1096           return self->Connect( func );
1097       }
1098 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)){
1099           self->Disconnect( func );
1100       }
1101 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){
1102           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1103 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1104       }
1105
1106 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1107          return self->Empty();
1108       }
1109 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1110         return self->GetConnectionCount();
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1113           self->Connect( func );
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Disconnect( func );
1117       }
1118 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1119           return self->Emit();
1120       }
1121
1122 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1123         std::vector< unsigned int >* pv = 0;
1124         if (capacity >= 0) {
1125           pv = new std::vector< unsigned int >();
1126           pv->reserve(capacity);
1127        } else {
1128           throw std::out_of_range("capacity");
1129        }
1130        return pv;
1131       }
1132 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(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 unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1139         if (index>=0 && index<(int)self->size())
1140           return (*self)[index];
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1145         if (index>=0 && index<(int)self->size())
1146           (*self)[index] = val;
1147         else
1148           throw std::out_of_range("index");
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1151         self->insert(self->end(), values.begin(), values.end());
1152       }
1153 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1154         if (index < 0)
1155           throw std::out_of_range("index");
1156         if (count < 0)
1157           throw std::out_of_range("count");
1158         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1159           throw std::invalid_argument("invalid range");
1160         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, x);
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1169         if (index>=0 && index<(int)self->size()+1)
1170           self->insert(self->begin()+index, values.begin(), values.end());
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1175         if (index>=0 && index<(int)self->size())
1176           self->erase(self->begin() + index);
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (count < 0)
1184           throw std::out_of_range("count");
1185         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1186           throw std::invalid_argument("invalid range");
1187         self->erase(self->begin()+index, self->begin()+index+count);
1188       }
1189 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1190         if (count < 0)
1191           throw std::out_of_range("count");
1192         return new std::vector< unsigned int >(count, value);
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1195         std::reverse(self->begin(), self->end());
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1198         if (index < 0)
1199           throw std::out_of_range("index");
1200         if (count < 0)
1201           throw std::out_of_range("count");
1202         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1203           throw std::invalid_argument("invalid range");
1204         std::reverse(self->begin()+index, self->begin()+index+count);
1205       }
1206 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1207         if (index < 0)
1208           throw std::out_of_range("index");
1209         if (index+values.size() > self->size())
1210           throw std::out_of_range("index");
1211         std::copy(values.begin(), values.end(), self->begin()+index);
1212       }
1213 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1214         return std::find(self->begin(), self->end(), value) != self->end();
1215       }
1216 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1217         int index = -1;
1218         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1219         if (it != self->end())
1220           index = (int)(it - self->begin());
1221         return index;
1222       }
1223 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1224         int index = -1;
1225         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1226         if (rit != self->rend())
1227           index = (int)(self->rend() - 1 - rit);
1228         return index;
1229       }
1230 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1231         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1232         if (it != self->end()) {
1233           self->erase(it);
1234           return true;
1235         }
1236         return false;
1237       }
1238 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){
1239         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1240         if (capacity >= 0) {
1241           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1242           pv->reserve(capacity);
1243        } else {
1244           throw std::out_of_range("capacity");
1245        }
1246        return pv;
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           return (*self)[index];
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__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1261         if (index>=0 && index<(int)self->size())
1262           (*self)[index] = val;
1263         else
1264           throw std::out_of_range("index");
1265       }
1266 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){
1267         self->insert(self->end(), values.begin(), values.end());
1268       }
1269 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){
1270         if (index < 0)
1271           throw std::out_of_range("index");
1272         if (count < 0)
1273           throw std::out_of_range("count");
1274         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1275           throw std::invalid_argument("invalid range");
1276         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, x);
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__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1285         if (index>=0 && index<(int)self->size()+1)
1286           self->insert(self->begin()+index, values.begin(), values.end());
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__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1291         if (index>=0 && index<(int)self->size())
1292           self->erase(self->begin() + index);
1293         else
1294           throw std::out_of_range("index");
1295       }
1296 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){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (count < 0)
1300           throw std::out_of_range("count");
1301         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1302           throw std::invalid_argument("invalid range");
1303         self->erase(self->begin()+index, self->begin()+index+count);
1304       }
1305 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){
1306         if (count < 0)
1307           throw std::out_of_range("count");
1308         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1309       }
1310 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){
1311         std::reverse(self->begin(), self->end());
1312       }
1313 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){
1314         if (index < 0)
1315           throw std::out_of_range("index");
1316         if (count < 0)
1317           throw std::out_of_range("count");
1318         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1319           throw std::invalid_argument("invalid range");
1320         std::reverse(self->begin()+index, self->begin()+index+count);
1321       }
1322 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){
1323         if (index < 0)
1324           throw std::out_of_range("index");
1325         if (index+values.size() > self->size())
1326           throw std::out_of_range("index");
1327         std::copy(values.begin(), values.end(), self->begin()+index);
1328       }
1329 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1330         std::vector< Dali::Actor >* pv = 0;
1331         if (capacity >= 0) {
1332           pv = new std::vector< Dali::Actor >();
1333           pv->reserve(capacity);
1334        } else {
1335           throw std::out_of_range("capacity");
1336        }
1337        return pv;
1338       }
1339 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(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 Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1346         if (index>=0 && index<(int)self->size())
1347           return (*self)[index];
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1352         if (index>=0 && index<(int)self->size())
1353           (*self)[index] = val;
1354         else
1355           throw std::out_of_range("index");
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1358         self->insert(self->end(), values.begin(), values.end());
1359       }
1360 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1361         if (index < 0)
1362           throw std::out_of_range("index");
1363         if (count < 0)
1364           throw std::out_of_range("count");
1365         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1366           throw std::invalid_argument("invalid range");
1367         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, x);
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1376         if (index>=0 && index<(int)self->size()+1)
1377           self->insert(self->begin()+index, values.begin(), values.end());
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1382         if (index>=0 && index<(int)self->size())
1383           self->erase(self->begin() + index);
1384         else
1385           throw std::out_of_range("index");
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (count < 0)
1391           throw std::out_of_range("count");
1392         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1393           throw std::invalid_argument("invalid range");
1394         self->erase(self->begin()+index, self->begin()+index+count);
1395       }
1396 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1397         if (count < 0)
1398           throw std::out_of_range("count");
1399         return new std::vector< Dali::Actor >(count, value);
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1402         std::reverse(self->begin(), self->end());
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1405         if (index < 0)
1406           throw std::out_of_range("index");
1407         if (count < 0)
1408           throw std::out_of_range("count");
1409         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1410           throw std::invalid_argument("invalid range");
1411         std::reverse(self->begin()+index, self->begin()+index+count);
1412       }
1413 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1414         if (index < 0)
1415           throw std::out_of_range("index");
1416         if (index+values.size() > self->size())
1417           throw std::out_of_range("index");
1418         std::copy(values.begin(), values.end(), self->begin()+index);
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 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 &)){
1427           self->Connect( func );
1428       }
1429 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 &)){
1430           self->Disconnect( func );
1431       }
1432 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){
1433           return self->Emit( arg );
1434       }
1435 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){
1436          return self->Empty();
1437       }
1438 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){
1439         return self->GetConnectionCount();
1440       }
1441 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)){
1442         self->Connect( func );
1443       }
1444 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)){
1445         self->Disconnect( func );
1446       }
1447 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){
1448         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1449 /*@SWIG@*/ self->Emit( arg1, arg2 );
1450       }
1451 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1452          return self->Empty();
1453       }
1454 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){
1455         return self->GetConnectionCount();
1456       }
1457 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)){
1458         self->Connect( func );
1459       }
1460 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)){
1461         self->Disconnect( func );
1462       }
1463 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){
1464         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1465 /*@SWIG@*/ self->Emit( arg1, arg2 );
1466       }
1467 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468          return self->Empty();
1469       }
1470 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471         return self->GetConnectionCount();
1472       }
1473 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)){
1474         self->Connect( func );
1475       }
1476 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)){
1477         self->Disconnect( func );
1478       }
1479 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){
1480         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1481 /*@SWIG@*/ self->Emit( arg1, arg2 );
1482       }
1483 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){
1484          return self->Empty();
1485       }
1486 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){
1487         return self->GetConnectionCount();
1488       }
1489 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)){
1490         self->Connect( func );
1491       }
1492 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)){
1493         self->Disconnect( func );
1494       }
1495 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){
1496         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1497 /*@SWIG@*/ self->Emit( arg1, arg2 );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 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)){
1506           self->Connect( func );
1507       }
1508 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)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1512           return self->Emit( arg );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515          return self->Empty();
1516       }
1517 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518         return self->GetConnectionCount();
1519       }
1520 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)){
1521           self->Connect( func );
1522       }
1523 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)){
1524           self->Disconnect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1527           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1528 /*@SWIG@*/ self->Emit( arg );
1529       }
1530 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){
1531          return self->Empty();
1532       }
1533 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){
1534         return self->GetConnectionCount();
1535       }
1536 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)){
1537           return self->Connect( func );
1538       }
1539 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)){
1540           self->Disconnect( func );
1541       }
1542 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){
1543           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1544 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1545       }
1546 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547          return self->Empty();
1548       }
1549 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550         return self->GetConnectionCount();
1551       }
1552 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)){
1553           self->Connect( func );
1554       }
1555 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)){
1556           self->Disconnect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1559           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1560 /*@SWIG@*/ self->Emit( arg );
1561       }
1562 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){
1563          return self->Empty();
1564       }
1565 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){
1566         return self->GetConnectionCount();
1567       }
1568 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)){
1569           return self->Connect( func );
1570       }
1571 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)){
1572           self->Disconnect( func );
1573       }
1574 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){
1575           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1576 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1577       }
1578 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){
1579          return self->Empty();
1580       }
1581 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){
1582         return self->GetConnectionCount();
1583       }
1584 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 &)){
1585           self->Connect( func );
1586       }
1587 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 &)){
1588           self->Disconnect( func );
1589       }
1590 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){
1591           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1592 /*@SWIG@*/ self->Emit( arg );
1593       }
1594 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1595          return self->Empty();
1596       }
1597 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){
1598         return self->GetConnectionCount();
1599       }
1600 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 &)){
1601           self->Connect( func );
1602       }
1603 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 &)){
1604           self->Disconnect( func );
1605       }
1606 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){
1607           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1608 /*@SWIG@*/ self->Emit( arg );
1609       }
1610
1611
1612 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){
1613          return self->Empty();
1614       }
1615 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){
1616         return self->GetConnectionCount();
1617       }
1618 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 &)){
1619         self->Connect( func );
1620       }
1621 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 &)){
1622         self->Disconnect( func );
1623       }
1624 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){
1625         return self->Emit( arg1, arg2 );
1626       }
1627 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1628          return self->Empty();
1629       }
1630 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631         return self->GetConnectionCount();
1632       }
1633 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)){
1634           self->Connect( func );
1635       }
1636 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)){
1637           self->Disconnect( func );
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1640           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1641 /*@SWIG@*/ self->Emit( arg );
1642       }
1643 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1644          return self->Empty();
1645       }
1646 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647         return self->GetConnectionCount();
1648       }
1649 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 &)){
1650           self->Connect( func );
1651       }
1652 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 &)){
1653           self->Disconnect( func );
1654       }
1655 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){
1656           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1657 /*@SWIG@*/ self->Emit( arg );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1660          return self->Empty();
1661       }
1662 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){
1663         return self->GetConnectionCount();
1664       }
1665 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)){
1666         self->Connect( func );
1667       }
1668 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)){
1669         self->Disconnect( func );
1670       }
1671 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){
1672         return self->Emit( arg1, arg2 );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1675          return self->Empty();
1676       }
1677 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){
1678         return self->GetConnectionCount();
1679       }
1680 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)){
1681         self->Connect( func );
1682       }
1683 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)){
1684         self->Disconnect( func );
1685       }
1686 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){
1687         return self->Emit( arg1, arg2 );
1688       }
1689
1690 /* ---------------------------------------------------
1691  * C++ director class methods
1692  * --------------------------------------------------- */
1693
1694 #include "dali_wrap.h"
1695
1696 /*
1697  *  Widget director
1698  */
1699 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1700   swig_init_callbacks();
1701 }
1702
1703 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1704 }
1705
1706 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1707   char * jcontentInfo = 0 ;
1708   void * jwindow  ;
1709
1710   if (!swig_callbackOnCreate) {
1711     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1712     return;
1713   } else {
1714     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1715     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1716     swig_callbackOnCreate(jcontentInfo, jwindow);
1717   }
1718 }
1719
1720 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1721   char * jcontentInfo = 0 ;
1722   int jtype  ;
1723
1724   if (!swig_callbackOnTerminate) {
1725     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1726     return;
1727   } else {
1728     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1729     jtype = (int)type;
1730     swig_callbackOnTerminate(jcontentInfo, jtype);
1731   }
1732 }
1733
1734 void SwigDirector_WidgetImpl::OnPause() {
1735   if (!swig_callbackOnPause) {
1736     Dali::Internal::Adaptor::Widget::OnPause();
1737     return;
1738   } else {
1739     swig_callbackOnPause();
1740   }
1741 }
1742
1743 void SwigDirector_WidgetImpl::OnResume() {
1744   if (!swig_callbackOnResume) {
1745     Dali::Internal::Adaptor::Widget::OnResume();
1746     return;
1747   } else {
1748     swig_callbackOnResume();
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1753   void * jwindow  ;
1754
1755   if (!swig_callbackOnResize) {
1756     Dali::Internal::Adaptor::Widget::OnResize(window);
1757     return;
1758   } else {
1759     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1760     swig_callbackOnResize(jwindow);
1761   }
1762 }
1763
1764 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1765   char * jcontentInfo = 0 ;
1766   int jforce  ;
1767
1768   if (!swig_callbackOnUpdate) {
1769     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1770     return;
1771   } else {
1772     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1773     jforce = force;
1774     swig_callbackOnUpdate(jcontentInfo, jforce);
1775   }
1776 }
1777
1778 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1779   void * jslotObserver = 0 ;
1780   void * jcallback = 0 ;
1781
1782   if (!swig_callbackSignalConnected) {
1783     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1784     return;
1785   } else {
1786     jslotObserver = (void *) slotObserver;
1787     jcallback = (void *) callback;
1788     swig_callbackSignalConnected(jslotObserver, jcallback);
1789   }
1790 }
1791
1792 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1793   void * jslotObserver = 0 ;
1794   void * jcallback = 0 ;
1795
1796   if (!swig_callbackSignalDisconnected) {
1797     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1798     return;
1799   } else {
1800     jslotObserver = (void *) slotObserver;
1801     jcallback = (void *) callback;
1802     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1803   }
1804 }
1805
1806 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) {
1807
1808   swig_callbackOnCreate = callbackOnCreate;
1809   swig_callbackOnTerminate = callbackOnTerminate;
1810   swig_callbackOnPause = callbackOnPause;
1811   swig_callbackOnResume = callbackOnResume;
1812   swig_callbackOnResize = callbackOnResize;
1813   swig_callbackOnUpdate = callbackOnUpdate;
1814   swig_callbackSignalConnected = callbackSignalConnected;
1815   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1816 }
1817
1818 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1819   swig_callbackOnCreate = 0;
1820   swig_callbackOnTerminate = 0;
1821   swig_callbackOnPause = 0;
1822   swig_callbackOnResume = 0;
1823   swig_callbackOnResize = 0;
1824   swig_callbackOnUpdate = 0;
1825   swig_callbackSignalConnected = 0;
1826   swig_callbackSignalDisconnected = 0;
1827 }
1828
1829
1830 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1831   swig_init_callbacks();
1832 }
1833
1834 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1835
1836 }
1837
1838
1839 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1840   int jdepth  ;
1841
1842   if (!swig_callbackOnStageConnection) {
1843     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1844     return;
1845   } else {
1846     jdepth = depth;
1847     swig_callbackOnStageConnection(jdepth);
1848   }
1849 }
1850
1851 void SwigDirector_ViewImpl::OnStageDisconnection() {
1852   if (!swig_callbackOnStageDisconnection) {
1853     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1854     return;
1855   } else {
1856     swig_callbackOnStageDisconnection();
1857   }
1858 }
1859
1860 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1861   void * jchild = 0 ;
1862
1863   if (!swig_callbackOnChildAdd) {
1864     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1865     return;
1866   } else {
1867     jchild = (Dali::Actor *) &child;
1868     swig_callbackOnChildAdd(jchild);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1873   void * jchild = 0 ;
1874
1875   if (!swig_callbackOnChildRemove) {
1876     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1877     return;
1878   } else {
1879     jchild = (Dali::Actor *) &child;
1880     swig_callbackOnChildRemove(jchild);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1885   int jindex  ;
1886   void * jpropertyValue  ;
1887
1888   if (!swig_callbackOnPropertySet) {
1889     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1890     return;
1891   } else {
1892     jindex = index;
1893     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1894     swig_callbackOnPropertySet(jindex, jpropertyValue);
1895   }
1896 }
1897
1898 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1899   void * jtargetSize = 0 ;
1900
1901   if (!swig_callbackOnSizeSet) {
1902     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1903     return;
1904   } else {
1905     jtargetSize = (Dali::Vector3 *) &targetSize;
1906     swig_callbackOnSizeSet(jtargetSize);
1907   }
1908 }
1909
1910 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1911   void * janimation = 0 ;
1912   void * jtargetSize = 0 ;
1913
1914   if (!swig_callbackOnSizeAnimation) {
1915     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1916     return;
1917   } else {
1918     janimation = (Dali::Animation *) &animation;
1919     jtargetSize = (Dali::Vector3 *) &targetSize;
1920     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1921   }
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnTouchEvent) {
1930     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1931   } else {
1932     jarg0 = (Dali::TouchEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnHoverEvent) {
1945     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1946   } else {
1947     jarg0 = (Dali::HoverEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1955   bool c_result = SwigValueInit< bool >() ;
1956   unsigned int jresult = 0 ;
1957   void * jarg0 = 0 ;
1958
1959   if (!swig_callbackOnKeyEvent) {
1960     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1961   } else {
1962     jarg0 = (Dali::KeyEvent *) &event;
1963     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1964     c_result = jresult ? true : false;
1965   }
1966   return c_result;
1967 }
1968
1969 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1970   bool c_result = SwigValueInit< bool >() ;
1971   unsigned int jresult = 0 ;
1972   void * jarg0 = 0 ;
1973
1974   if (!swig_callbackOnWheelEvent) {
1975     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1976   } else {
1977     jarg0 = (Dali::WheelEvent *) &event;
1978     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1979     c_result = jresult ? true : false;
1980   }
1981   return c_result;
1982 }
1983
1984 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1985   void * jsize = 0 ;
1986   void * jcontainer = 0 ;
1987
1988   if (!swig_callbackOnRelayout) {
1989     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1990     return;
1991   } else {
1992     jsize = (Dali::Vector2 *) &size;
1993     jcontainer = (Dali::RelayoutContainer *) &container;
1994     swig_callbackOnRelayout(jsize, jcontainer);
1995   }
1996 }
1997
1998 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1999   int jpolicy  ;
2000   int jdimension  ;
2001
2002   if (!swig_callbackOnSetResizePolicy) {
2003     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2004     return;
2005   } else {
2006     jpolicy = (int)policy;
2007     jdimension = (int)dimension;
2008     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2009   }
2010 }
2011
2012 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2013   Dali::Vector3 c_result ;
2014   void * jresult = 0 ;
2015
2016   if (!swig_callbackGetNaturalSize) {
2017     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2018   } else {
2019     jresult = (void *) swig_callbackGetNaturalSize();
2020     if (!jresult) {
2021       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2022       return c_result;
2023     }
2024     c_result = *(Dali::Vector3 *)jresult;
2025   }
2026   return c_result;
2027 }
2028
2029 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2030   float c_result = SwigValueInit< float >() ;
2031   float jresult = 0 ;
2032   void * jchild = 0 ;
2033   int jdimension  ;
2034
2035   if (!swig_callbackCalculateChildSize) {
2036     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2037   } else {
2038     jchild = (Dali::Actor *) &child;
2039     jdimension = (int)dimension;
2040     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2047   float c_result = SwigValueInit< float >() ;
2048   float jresult = 0 ;
2049   float jwidth  ;
2050
2051   if (!swig_callbackGetHeightForWidth) {
2052     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2053   } else {
2054     jwidth = width;
2055     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2056     c_result = (float)jresult;
2057   }
2058   return c_result;
2059 }
2060
2061 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2062   float c_result = SwigValueInit< float >() ;
2063   float jresult = 0 ;
2064   float jheight  ;
2065
2066   if (!swig_callbackGetWidthForHeight) {
2067     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2068   } else {
2069     jheight = height;
2070     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2071     c_result = (float)jresult;
2072   }
2073   return c_result;
2074 }
2075
2076 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2077   bool c_result = SwigValueInit< bool >() ;
2078   unsigned int jresult = 0 ;
2079   int jdimension  ;
2080
2081   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2082     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2083   } else {
2084     jdimension = (int)dimension;
2085     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2086     c_result = jresult ? true : false;
2087   }
2088   return c_result;
2089 }
2090
2091 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2092   int jdimension  ;
2093
2094   if (!swig_callbackOnCalculateRelayoutSize) {
2095     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2096     return;
2097   } else {
2098     jdimension = (int)dimension;
2099     swig_callbackOnCalculateRelayoutSize(jdimension);
2100   }
2101 }
2102
2103 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2104   float jsize  ;
2105   int jdimension  ;
2106
2107   if (!swig_callbackOnLayoutNegotiated) {
2108     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2109     return;
2110   } else {
2111     jsize = size;
2112     jdimension = (int)dimension;
2113     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2114   }
2115 }
2116
2117 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2118   return Dali::CustomActorImpl::GetExtension();
2119 }
2120
2121 void SwigDirector_ViewImpl::OnInitialize() {
2122   if (!swig_callbackOnInitialize) {
2123     Dali::Toolkit::Internal::Control::OnInitialize();
2124     return;
2125   } else {
2126     swig_callbackOnInitialize();
2127   }
2128 }
2129
2130 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2131   void * jchild = 0 ;
2132
2133   if (!swig_callbackOnControlChildAdd) {
2134     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2135     return;
2136   } else {
2137     jchild = (Dali::Actor *) &child;
2138     swig_callbackOnControlChildAdd(jchild);
2139   }
2140 }
2141
2142 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2143   void * jchild = 0 ;
2144
2145   if (!swig_callbackOnControlChildRemove) {
2146     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2147     return;
2148   } else {
2149     jchild = (Dali::Actor *) &child;
2150     swig_callbackOnControlChildRemove(jchild);
2151   }
2152 }
2153
2154 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2155   void * jstyleManager  ;
2156   int jchange  ;
2157
2158   if (!swig_callbackOnStyleChange) {
2159     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2160     return;
2161   } else {
2162     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2163     jchange = (int)change;
2164     swig_callbackOnStyleChange(jstyleManager, jchange);
2165   }
2166 }
2167
2168 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2169   bool c_result = SwigValueInit< bool >() ;
2170   unsigned int jresult = 0 ;
2171
2172   if (!swig_callbackOnAccessibilityActivated) {
2173     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2174   } else {
2175     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2176     c_result = jresult ? true : false;
2177   }
2178   return c_result;
2179 }
2180
2181 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2182   bool c_result = SwigValueInit< bool >() ;
2183   unsigned int jresult = 0 ;
2184   void * jgesture  ;
2185
2186   if (!swig_callbackOnAccessibilityPan) {
2187     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2188   } else {
2189     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2190     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2191     c_result = jresult ? true : false;
2192   }
2193   return c_result;
2194 }
2195
2196 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2197   bool c_result = SwigValueInit< bool >() ;
2198   unsigned int jresult = 0 ;
2199   void * jtouchEvent = 0 ;
2200
2201   if (!swig_callbackOnAccessibilityTouch) {
2202     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2203   } else {
2204     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2205     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2206     c_result = jresult ? true : false;
2207   }
2208   return c_result;
2209 }
2210
2211 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2212   bool c_result = SwigValueInit< bool >() ;
2213   unsigned int jresult = 0 ;
2214   unsigned int jisIncrease  ;
2215
2216   if (!swig_callbackOnAccessibilityValueChange) {
2217     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2218   } else {
2219     jisIncrease = isIncrease;
2220     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2221     c_result = jresult ? true : false;
2222   }
2223   return c_result;
2224 }
2225
2226 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2227   bool c_result = SwigValueInit< bool >() ;
2228   unsigned int jresult = 0 ;
2229
2230   if (!swig_callbackOnAccessibilityZoom) {
2231     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2232   } else {
2233     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2234     c_result = jresult ? true : false;
2235   }
2236   return c_result;
2237 }
2238
2239 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2240   if (!swig_callbackOnKeyInputFocusGained) {
2241     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2242     return;
2243   } else {
2244     swig_callbackOnKeyInputFocusGained();
2245   }
2246 }
2247
2248 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2249   if (!swig_callbackOnKeyInputFocusLost) {
2250     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2251     return;
2252   } else {
2253     swig_callbackOnKeyInputFocusLost();
2254   }
2255 }
2256
2257 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2258   Dali::Actor c_result ;
2259   void * jresult = 0 ;
2260   void * jcurrentFocusedActor  ;
2261   int jdirection  ;
2262   unsigned int jloopEnabled  ;
2263
2264   if (!swig_callbackGetNextKeyboardFocusableActor) {
2265     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2266   } else {
2267     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2268     jdirection = (int)direction;
2269     jloopEnabled = loopEnabled;
2270     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2271     if (!jresult) {
2272       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2273       return c_result;
2274     }
2275     c_result = *(Dali::Actor *)jresult;
2276   }
2277   return c_result;
2278 }
2279
2280 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2281   void * jcommitedFocusableActor  ;
2282
2283   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2284     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2285     return;
2286   } else {
2287     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2288     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2289   }
2290 }
2291
2292 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2293   bool c_result = SwigValueInit< bool >() ;
2294   unsigned int jresult = 0 ;
2295
2296   if (!swig_callbackOnKeyboardEnter) {
2297     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2298   } else {
2299     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2300     c_result = jresult ? true : false;
2301   }
2302   return c_result;
2303 }
2304
2305 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2306   void * jpinch = 0 ;
2307
2308   if (!swig_callbackOnPinch) {
2309     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2310     return;
2311   } else {
2312     jpinch = (Dali::PinchGesture *) &pinch;
2313     swig_callbackOnPinch(jpinch);
2314   }
2315 }
2316
2317 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2318   void * jpan = 0 ;
2319
2320   if (!swig_callbackOnPan) {
2321     Dali::Toolkit::Internal::Control::OnPan(pan);
2322     return;
2323   } else {
2324     jpan = (Dali::PanGesture *) &pan;
2325     swig_callbackOnPan(jpan);
2326   }
2327 }
2328
2329 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2330   void * jtap = 0 ;
2331
2332   if (!swig_callbackOnTap) {
2333     Dali::Toolkit::Internal::Control::OnTap(tap);
2334     return;
2335   } else {
2336     jtap = (Dali::TapGesture *) &tap;
2337     swig_callbackOnTap(jtap);
2338   }
2339 }
2340
2341 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2342   void * jlongPress = 0 ;
2343
2344   if (!swig_callbackOnLongPress) {
2345     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2346     return;
2347   } else {
2348     jlongPress = (Dali::LongPressGesture *) &longPress;
2349     swig_callbackOnLongPress(jlongPress);
2350   }
2351 }
2352
2353 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2354   void * jslotObserver = 0 ;
2355   void * jcallback = 0 ;
2356
2357   if (!swig_callbackSignalConnected) {
2358     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2359     return;
2360   } else {
2361     jslotObserver = (void *) slotObserver;
2362     jcallback = (void *) callback;
2363     swig_callbackSignalConnected(jslotObserver, jcallback);
2364   }
2365 }
2366
2367 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2368   void * jslotObserver = 0 ;
2369   void * jcallback = 0 ;
2370
2371   if (!swig_callbackSignalDisconnected) {
2372     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2373     return;
2374   } else {
2375     jslotObserver = (void *) slotObserver;
2376     jcallback = (void *) callback;
2377     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2378   }
2379 }
2380
2381 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2382   return Dali::Toolkit::Internal::Control::GetControlExtension();
2383 }
2384
2385 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) {
2386   swig_callbackOnStageConnection = callbackOnStageConnection;
2387   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2388   swig_callbackOnChildAdd = callbackOnChildAdd;
2389   swig_callbackOnChildRemove = callbackOnChildRemove;
2390   swig_callbackOnPropertySet = callbackOnPropertySet;
2391   swig_callbackOnSizeSet = callbackOnSizeSet;
2392   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2393   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2394   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2395   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2396   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2397   swig_callbackOnRelayout = callbackOnRelayout;
2398   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2399   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2400   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2401   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2402   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2403   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2405   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2406   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2407   swig_callbackOnInitialize = callbackOnInitialize;
2408   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2409   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2410   swig_callbackOnStyleChange = callbackOnStyleChange;
2411   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2412   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2413   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2414   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2415   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2416   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2417   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2418   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2419   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2420   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2421   swig_callbackOnPinch = callbackOnPinch;
2422   swig_callbackOnPan = callbackOnPan;
2423   swig_callbackOnTap = callbackOnTap;
2424   swig_callbackOnLongPress = callbackOnLongPress;
2425   swig_callbackSignalConnected = callbackSignalConnected;
2426   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2427 }
2428
2429 void SwigDirector_ViewImpl::swig_init_callbacks() {
2430   swig_callbackOnStageConnection = 0;
2431   swig_callbackOnStageDisconnection = 0;
2432   swig_callbackOnChildAdd = 0;
2433   swig_callbackOnChildRemove = 0;
2434   swig_callbackOnPropertySet = 0;
2435   swig_callbackOnSizeSet = 0;
2436   swig_callbackOnSizeAnimation = 0;
2437   swig_callbackOnTouchEvent = 0;
2438   swig_callbackOnHoverEvent = 0;
2439   swig_callbackOnKeyEvent = 0;
2440   swig_callbackOnWheelEvent = 0;
2441   swig_callbackOnRelayout = 0;
2442   swig_callbackOnSetResizePolicy = 0;
2443   swig_callbackGetNaturalSize = 0;
2444   swig_callbackCalculateChildSize = 0;
2445   swig_callbackGetHeightForWidth = 0;
2446   swig_callbackGetWidthForHeight = 0;
2447   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2449   swig_callbackOnCalculateRelayoutSize = 0;
2450   swig_callbackOnLayoutNegotiated = 0;
2451   swig_callbackOnInitialize = 0;
2452   swig_callbackOnControlChildAdd = 0;
2453   swig_callbackOnControlChildRemove = 0;
2454   swig_callbackOnStyleChange = 0;
2455   swig_callbackOnAccessibilityActivated = 0;
2456   swig_callbackOnAccessibilityPan = 0;
2457   swig_callbackOnAccessibilityTouch = 0;
2458   swig_callbackOnAccessibilityValueChange = 0;
2459   swig_callbackOnAccessibilityZoom = 0;
2460   swig_callbackOnKeyInputFocusGained = 0;
2461   swig_callbackOnKeyInputFocusLost = 0;
2462   swig_callbackGetNextKeyboardFocusableActor = 0;
2463   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2464   swig_callbackOnKeyboardEnter = 0;
2465   swig_callbackOnPinch = 0;
2466   swig_callbackOnPan = 0;
2467   swig_callbackOnTap = 0;
2468   swig_callbackOnLongPress = 0;
2469   swig_callbackSignalConnected = 0;
2470   swig_callbackSignalDisconnected = 0;
2471 }
2472
2473 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2474   swig_init_callbacks();
2475 }
2476
2477 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2478
2479 }
2480
2481
2482 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2483   unsigned int c_result = SwigValueInit< unsigned int >() ;
2484   unsigned int jresult = 0 ;
2485
2486   if (!swig_callbackGetNumberOfItems) {
2487     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2488   } else {
2489     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2490     c_result = (unsigned int)jresult;
2491   }
2492   return c_result;
2493 }
2494
2495 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2496   Dali::Actor c_result ;
2497   void * jresult = 0 ;
2498   unsigned int jitemId  ;
2499
2500   if (!swig_callbackNewItem) {
2501     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2502   } else {
2503     jitemId = itemId;
2504     jresult = (void *) swig_callbackNewItem(jitemId);
2505     if (!jresult) {
2506       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2507       return c_result;
2508     }
2509     c_result = *(Dali::Actor *)jresult;
2510   }
2511   return c_result;
2512 }
2513
2514 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2515   unsigned int jitemId  ;
2516   void * jactor  ;
2517
2518   if (!swig_callbackItemReleased) {
2519     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2520     return;
2521   } else {
2522     jitemId = itemId;
2523     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2524     swig_callbackItemReleased(jitemId, jactor);
2525   }
2526 }
2527
2528 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2529   return Dali::Toolkit::ItemFactory::GetExtension();
2530 }
2531
2532 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2533   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2534   swig_callbackNewItem = callbackNewItem;
2535   swig_callbackItemReleased = callbackItemReleased;
2536 }
2537
2538 void SwigDirector_ItemFactory::swig_init_callbacks() {
2539   swig_callbackGetNumberOfItems = 0;
2540   swig_callbackNewItem = 0;
2541   swig_callbackItemReleased = 0;
2542 }
2543
2544 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2545   swig_init_callbacks();
2546 }
2547
2548 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2549
2550 }
2551
2552
2553 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2554   Dali::Actor c_result ;
2555   void * jresult = 0 ;
2556   void * jcurrent  ;
2557   void * jproposed  ;
2558   int jdirection  ;
2559
2560   if (!swig_callbackGetNextFocusableActor) {
2561     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2562   } else {
2563     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2564     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2565     jdirection = (int)direction;
2566     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2567     if (!jresult) {
2568       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2569       return c_result;
2570     }
2571     c_result = *(Dali::Actor *)jresult;
2572   }
2573   return c_result;
2574 }
2575
2576 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2577   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2578 }
2579
2580 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2581   swig_callbackGetNextFocusableActor = 0;
2582 }
2583
2584
2585 #ifdef __cplusplus
2586 extern "C" {
2587 #endif
2588
2589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2590   void * jresult ;
2591   floatp *result = 0 ;
2592
2593   {
2594     try {
2595       result = (floatp *)new_floatp();
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (DaliException e) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2611       };
2612     }
2613   }
2614   jresult = (void *)result;
2615   return jresult;
2616 }
2617
2618
2619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2620   floatp *arg1 = (floatp *) 0 ;
2621
2622   arg1 = (floatp *)jarg1;
2623   {
2624     try {
2625       delete_floatp(arg1);
2626     } catch (std::out_of_range& e) {
2627       {
2628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2629       };
2630     } catch (std::exception& e) {
2631       {
2632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2633       };
2634     } catch (Dali::DaliException e) {
2635       {
2636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2637       };
2638     } catch (...) {
2639       {
2640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2641       };
2642     }
2643   }
2644
2645 }
2646
2647
2648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2649   floatp *arg1 = (floatp *) 0 ;
2650   float arg2 ;
2651
2652   arg1 = (floatp *)jarg1;
2653   arg2 = (float)jarg2;
2654   {
2655     try {
2656       floatp_assign(arg1,arg2);
2657     } catch (std::out_of_range& e) {
2658       {
2659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2660       };
2661     } catch (std::exception& e) {
2662       {
2663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2664       };
2665     } catch (Dali::DaliException e) {
2666       {
2667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2668       };
2669     } catch (...) {
2670       {
2671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2672       };
2673     }
2674   }
2675
2676 }
2677
2678
2679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2680   float jresult ;
2681   floatp *arg1 = (floatp *) 0 ;
2682   float result;
2683
2684   arg1 = (floatp *)jarg1;
2685   {
2686     try {
2687       result = (float)floatp_value(arg1);
2688     } catch (std::out_of_range& e) {
2689       {
2690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2691       };
2692     } catch (std::exception& e) {
2693       {
2694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2695       };
2696     } catch (DaliException e) {
2697       {
2698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2699       };
2700     } catch (...) {
2701       {
2702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2703       };
2704     }
2705   }
2706   jresult = result;
2707   return jresult;
2708 }
2709
2710
2711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2712   void * jresult ;
2713   floatp *arg1 = (floatp *) 0 ;
2714   float *result = 0 ;
2715
2716   arg1 = (floatp *)jarg1;
2717   {
2718     try {
2719       result = (float *)floatp_cast(arg1);
2720     } catch (std::out_of_range& e) {
2721       {
2722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2723       };
2724     } catch (std::exception& e) {
2725       {
2726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2727       };
2728     } catch (Dali::DaliException e) {
2729       {
2730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2731       };
2732     } catch (...) {
2733       {
2734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2735       };
2736     }
2737   }
2738
2739   jresult = (void *)result;
2740   return jresult;
2741 }
2742
2743
2744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2745   void * jresult ;
2746   float *arg1 = (float *) 0 ;
2747   floatp *result = 0 ;
2748
2749   arg1 = (float *)jarg1;
2750   {
2751     try {
2752       result = (floatp *)floatp_frompointer(arg1);
2753     } catch (std::out_of_range& e) {
2754       {
2755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2756       };
2757     } catch (std::exception& e) {
2758       {
2759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2760       };
2761     } catch (Dali::DaliException e) {
2762       {
2763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2764       };
2765     } catch (...) {
2766       {
2767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2768       };
2769     }
2770   }
2771
2772   jresult = (void *)result;
2773   return jresult;
2774 }
2775
2776
2777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2778   void * jresult ;
2779   intp *result = 0 ;
2780
2781   {
2782     try {
2783       result = (intp *)new_intp();
2784     } catch (std::out_of_range& e) {
2785       {
2786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2787       };
2788     } catch (std::exception& e) {
2789       {
2790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (Dali::DaliException e) {
2793       {
2794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2795       };
2796     } catch (...) {
2797       {
2798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2799       };
2800     }
2801   }
2802
2803   jresult = (void *)result;
2804   return jresult;
2805 }
2806
2807
2808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2809   intp *arg1 = (intp *) 0 ;
2810
2811   arg1 = (intp *)jarg1;
2812   {
2813     try {
2814       delete_intp(arg1);
2815     } catch (std::out_of_range& e) {
2816       {
2817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2818       };
2819     } catch (std::exception& e) {
2820       {
2821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2822       };
2823     } catch (Dali::DaliException e) {
2824       {
2825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2826       };
2827     } catch (...) {
2828       {
2829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2830       };
2831     }
2832   }
2833
2834 }
2835
2836
2837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2838   intp *arg1 = (intp *) 0 ;
2839   int arg2 ;
2840
2841   arg1 = (intp *)jarg1;
2842   arg2 = (int)jarg2;
2843   {
2844     try {
2845       intp_assign(arg1,arg2);
2846     } catch (std::out_of_range& e) {
2847       {
2848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2849       };
2850     } catch (std::exception& e) {
2851       {
2852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2853       };
2854     } catch (Dali::DaliException e) {
2855       {
2856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2857       };
2858     } catch (...) {
2859       {
2860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2861       };
2862     }
2863   }
2864
2865 }
2866
2867
2868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2869   int jresult ;
2870   intp *arg1 = (intp *) 0 ;
2871   int result;
2872
2873   arg1 = (intp *)jarg1;
2874   {
2875     try {
2876       result = (int)intp_value(arg1);
2877     } catch (std::out_of_range& e) {
2878       {
2879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2880       };
2881     } catch (std::exception& e) {
2882       {
2883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2884       };
2885     } catch (Dali::DaliException e) {
2886       {
2887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2888       };
2889     } catch (...) {
2890       {
2891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2892       };
2893     }
2894   }
2895
2896   jresult = result;
2897   return jresult;
2898 }
2899
2900
2901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2902   void * jresult ;
2903   intp *arg1 = (intp *) 0 ;
2904   int *result = 0 ;
2905
2906   arg1 = (intp *)jarg1;
2907   {
2908     try {
2909       result = (int *)intp_cast(arg1);
2910     } catch (std::out_of_range& e) {
2911       {
2912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2913       };
2914     } catch (std::exception& e) {
2915       {
2916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2917       };
2918     } catch (Dali::DaliException e) {
2919       {
2920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2921       };
2922     } catch (...) {
2923       {
2924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2925       };
2926     }
2927   }
2928
2929   jresult = (void *)result;
2930   return jresult;
2931 }
2932
2933
2934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2935   void * jresult ;
2936   int *arg1 = (int *) 0 ;
2937   intp *result = 0 ;
2938
2939   arg1 = (int *)jarg1;
2940   {
2941     try {
2942       result = (intp *)intp_frompointer(arg1);
2943     } catch (std::out_of_range& e) {
2944       {
2945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2946       };
2947     } catch (std::exception& e) {
2948       {
2949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (Dali::DaliException e) {
2952       {
2953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961
2962   jresult = (void *)result;
2963   return jresult;
2964 }
2965
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2968   void * jresult ;
2969   doublep *result = 0 ;
2970
2971   {
2972     try {
2973       result = (doublep *)new_doublep();
2974     } catch (std::out_of_range& e) {
2975       {
2976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (std::exception& e) {
2979       {
2980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2981       };
2982     } catch (Dali::DaliException e) {
2983       {
2984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2985       };
2986     } catch (...) {
2987       {
2988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2989       };
2990     }
2991   }
2992
2993   jresult = (void *)result;
2994   return jresult;
2995 }
2996
2997
2998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2999   doublep *arg1 = (doublep *) 0 ;
3000
3001   arg1 = (doublep *)jarg1;
3002   {
3003     try {
3004       delete_doublep(arg1);
3005     } catch (std::out_of_range& e) {
3006       {
3007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3008       };
3009     } catch (std::exception& e) {
3010       {
3011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3012       };
3013     } catch (Dali::DaliException e) {
3014       {
3015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3016       };
3017     } catch (...) {
3018       {
3019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3020       };
3021     }
3022   }
3023
3024 }
3025
3026
3027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3028   doublep *arg1 = (doublep *) 0 ;
3029   double arg2 ;
3030
3031   arg1 = (doublep *)jarg1;
3032   arg2 = (double)jarg2;
3033   {
3034     try {
3035       doublep_assign(arg1,arg2);
3036     } catch (std::out_of_range& e) {
3037       {
3038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3039       };
3040     } catch (std::exception& e) {
3041       {
3042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3043       };
3044     } catch (Dali::DaliException e) {
3045       {
3046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3047       };
3048     } catch (...) {
3049       {
3050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3051       };
3052     }
3053   }
3054
3055 }
3056
3057
3058 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3059   double jresult ;
3060   doublep *arg1 = (doublep *) 0 ;
3061   double result;
3062
3063   arg1 = (doublep *)jarg1;
3064   {
3065     try {
3066       result = (double)doublep_value(arg1);
3067     } catch (std::out_of_range& e) {
3068       {
3069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3070       };
3071     } catch (std::exception& e) {
3072       {
3073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3074       };
3075     } catch (Dali::DaliException e) {
3076       {
3077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3078       };
3079     } catch (...) {
3080       {
3081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3082       };
3083     }
3084   }
3085
3086   jresult = result;
3087   return jresult;
3088 }
3089
3090
3091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3092   void * jresult ;
3093   doublep *arg1 = (doublep *) 0 ;
3094   double *result = 0 ;
3095
3096   arg1 = (doublep *)jarg1;
3097   {
3098     try {
3099       result = (double *)doublep_cast(arg1);
3100     } catch (std::out_of_range& e) {
3101       {
3102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3103       };
3104     } catch (std::exception& e) {
3105       {
3106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3107       };
3108     } catch (Dali::DaliException e) {
3109       {
3110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3111       };
3112     } catch (...) {
3113       {
3114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3115       };
3116     }
3117   }
3118
3119   jresult = (void *)result;
3120   return jresult;
3121 }
3122
3123
3124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3125   void * jresult ;
3126   double *arg1 = (double *) 0 ;
3127   doublep *result = 0 ;
3128
3129   arg1 = (double *)jarg1;
3130   {
3131     try {
3132       result = (doublep *)doublep_frompointer(arg1);
3133     } catch (std::out_of_range& e) {
3134       {
3135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3136       };
3137     } catch (std::exception& e) {
3138       {
3139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3140       };
3141     } catch (Dali::DaliException e) {
3142       {
3143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3144       };
3145     } catch (...) {
3146       {
3147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3148       };
3149     }
3150   }
3151
3152   jresult = (void *)result;
3153   return jresult;
3154 }
3155
3156
3157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3158   void * jresult ;
3159   uintp *result = 0 ;
3160
3161   {
3162     try {
3163       result = (uintp *)new_uintp();
3164     } catch (std::out_of_range& e) {
3165       {
3166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3167       };
3168     } catch (std::exception& e) {
3169       {
3170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3171       };
3172     } catch (Dali::DaliException e) {
3173       {
3174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3175       };
3176     } catch (...) {
3177       {
3178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3179       };
3180     }
3181   }
3182
3183   jresult = (void *)result;
3184   return jresult;
3185 }
3186
3187
3188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3189   uintp *arg1 = (uintp *) 0 ;
3190
3191   arg1 = (uintp *)jarg1;
3192   {
3193     try {
3194       delete_uintp(arg1);
3195     } catch (std::out_of_range& e) {
3196       {
3197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3198       };
3199     } catch (std::exception& e) {
3200       {
3201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3202       };
3203     } catch (Dali::DaliException e) {
3204       {
3205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3206       };
3207     } catch (...) {
3208       {
3209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3210       };
3211     }
3212   }
3213
3214 }
3215
3216
3217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3218   uintp *arg1 = (uintp *) 0 ;
3219   unsigned int arg2 ;
3220
3221   arg1 = (uintp *)jarg1;
3222   arg2 = (unsigned int)jarg2;
3223   {
3224     try {
3225       uintp_assign(arg1,arg2);
3226     } catch (std::out_of_range& e) {
3227       {
3228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3229       };
3230     } catch (std::exception& e) {
3231       {
3232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3233       };
3234     } catch (Dali::DaliException e) {
3235       {
3236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3237       };
3238     } catch (...) {
3239       {
3240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3241       };
3242     }
3243   }
3244
3245 }
3246
3247
3248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3249   unsigned int jresult ;
3250   uintp *arg1 = (uintp *) 0 ;
3251   unsigned int result;
3252
3253   arg1 = (uintp *)jarg1;
3254   {
3255     try {
3256       result = (unsigned int)uintp_value(arg1);
3257     } catch (std::out_of_range& e) {
3258       {
3259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3260       };
3261     } catch (std::exception& e) {
3262       {
3263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3264       };
3265     } catch (Dali::DaliException e) {
3266       {
3267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3268       };
3269     } catch (...) {
3270       {
3271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3272       };
3273     }
3274   }
3275
3276   jresult = result;
3277   return jresult;
3278 }
3279
3280
3281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3282   void * jresult ;
3283   uintp *arg1 = (uintp *) 0 ;
3284   unsigned int *result = 0 ;
3285
3286   arg1 = (uintp *)jarg1;
3287   {
3288     try {
3289       result = (unsigned int *)uintp_cast(arg1);
3290     } catch (std::out_of_range& e) {
3291       {
3292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3293       };
3294     } catch (std::exception& e) {
3295       {
3296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3297       };
3298     } catch (Dali::DaliException e) {
3299       {
3300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3301       };
3302     } catch (...) {
3303       {
3304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3305       };
3306     }
3307   }
3308
3309   jresult = (void *)result;
3310   return jresult;
3311 }
3312
3313
3314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3315   void * jresult ;
3316   unsigned int *arg1 = (unsigned int *) 0 ;
3317   uintp *result = 0 ;
3318
3319   arg1 = (unsigned int *)jarg1;
3320   {
3321     try {
3322       result = (uintp *)uintp_frompointer(arg1);
3323     } catch (std::out_of_range& e) {
3324       {
3325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3326       };
3327     } catch (std::exception& e) {
3328       {
3329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3330       };
3331     } catch (Dali::DaliException e) {
3332       {
3333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3334       };
3335     } catch (...) {
3336       {
3337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3338       };
3339     }
3340   }
3341
3342   jresult = (void *)result;
3343   return jresult;
3344 }
3345
3346
3347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3348   void * jresult ;
3349   ushortp *result = 0 ;
3350
3351   {
3352     try {
3353       result = (ushortp *)new_ushortp();
3354     } catch (std::out_of_range& e) {
3355       {
3356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3357       };
3358     } catch (std::exception& e) {
3359       {
3360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3361       };
3362     } catch (Dali::DaliException e) {
3363       {
3364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3365       };
3366     } catch (...) {
3367       {
3368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3369       };
3370     }
3371   }
3372
3373   jresult = (void *)result;
3374   return jresult;
3375 }
3376
3377
3378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3379   ushortp *arg1 = (ushortp *) 0 ;
3380
3381   arg1 = (ushortp *)jarg1;
3382   {
3383     try {
3384       delete_ushortp(arg1);
3385     } catch (std::out_of_range& e) {
3386       {
3387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3388       };
3389     } catch (std::exception& e) {
3390       {
3391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3392       };
3393     } catch (Dali::DaliException e) {
3394       {
3395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3396       };
3397     } catch (...) {
3398       {
3399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3400       };
3401     }
3402   }
3403
3404 }
3405
3406
3407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3408   ushortp *arg1 = (ushortp *) 0 ;
3409   unsigned short arg2 ;
3410
3411   arg1 = (ushortp *)jarg1;
3412   arg2 = (unsigned short)jarg2;
3413   {
3414     try {
3415       ushortp_assign(arg1,arg2);
3416     } catch (std::out_of_range& e) {
3417       {
3418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3419       };
3420     } catch (std::exception& e) {
3421       {
3422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (Dali::DaliException e) {
3425       {
3426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434
3435 }
3436
3437
3438 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3439   unsigned short jresult ;
3440   ushortp *arg1 = (ushortp *) 0 ;
3441   unsigned short result;
3442
3443   arg1 = (ushortp *)jarg1;
3444   {
3445     try {
3446       result = (unsigned short)ushortp_value(arg1);
3447     } catch (std::out_of_range& e) {
3448       {
3449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3450       };
3451     } catch (std::exception& e) {
3452       {
3453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3454       };
3455     } catch (Dali::DaliException e) {
3456       {
3457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3458       };
3459     } catch (...) {
3460       {
3461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3462       };
3463     }
3464   }
3465
3466   jresult = result;
3467   return jresult;
3468 }
3469
3470
3471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3472   void * jresult ;
3473   ushortp *arg1 = (ushortp *) 0 ;
3474   unsigned short *result = 0 ;
3475
3476   arg1 = (ushortp *)jarg1;
3477   {
3478     try {
3479       result = (unsigned short *)ushortp_cast(arg1);
3480     } catch (std::out_of_range& e) {
3481       {
3482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3483       };
3484     } catch (std::exception& e) {
3485       {
3486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3487       };
3488     } catch (Dali::DaliException e) {
3489       {
3490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3491       };
3492     } catch (...) {
3493       {
3494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3495       };
3496     }
3497   }
3498
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3505   void * jresult ;
3506   unsigned short *arg1 = (unsigned short *) 0 ;
3507   ushortp *result = 0 ;
3508
3509   arg1 = (unsigned short *)jarg1;
3510   {
3511     try {
3512       result = (ushortp *)ushortp_frompointer(arg1);
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (Dali::DaliException e) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3524       };
3525     } catch (...) {
3526       {
3527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3528       };
3529     }
3530   }
3531
3532   jresult = (void *)result;
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3538   unsigned int jresult ;
3539   int arg1 ;
3540   unsigned int result;
3541
3542   arg1 = (int)jarg1;
3543   {
3544     try {
3545       result = (unsigned int)int_to_uint(arg1);
3546     } catch (std::out_of_range& e) {
3547       {
3548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3549       };
3550     } catch (std::exception& e) {
3551       {
3552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3553       };
3554     } catch (Dali::DaliException e) {
3555       {
3556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3557       };
3558     } catch (...) {
3559       {
3560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3561       };
3562     }
3563   }
3564
3565   jresult = result;
3566   return jresult;
3567 }
3568
3569
3570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3571   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3572
3573   arg1 = (Dali::RefObject *)jarg1;
3574   {
3575     try {
3576       (arg1)->Reference();
3577     } catch (std::out_of_range& e) {
3578       {
3579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3580       };
3581     } catch (std::exception& e) {
3582       {
3583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3584       };
3585     } catch (Dali::DaliException e) {
3586       {
3587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3588       };
3589     } catch (...) {
3590       {
3591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3592       };
3593     }
3594   }
3595
3596 }
3597
3598
3599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3600   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3601
3602   arg1 = (Dali::RefObject *)jarg1;
3603   {
3604     try {
3605       (arg1)->Unreference();
3606     } catch (std::out_of_range& e) {
3607       {
3608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3609       };
3610     } catch (std::exception& e) {
3611       {
3612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3613       };
3614     } catch (Dali::DaliException e) {
3615       {
3616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3617       };
3618     } catch (...) {
3619       {
3620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3621       };
3622     }
3623   }
3624
3625 }
3626
3627
3628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3629   int jresult ;
3630   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3631   int result;
3632
3633   arg1 = (Dali::RefObject *)jarg1;
3634   {
3635     try {
3636       result = (int)(arg1)->ReferenceCount();
3637     } catch (std::out_of_range& e) {
3638       {
3639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3640       };
3641     } catch (std::exception& e) {
3642       {
3643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3644       };
3645     } catch (Dali::DaliException e) {
3646       {
3647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3648       };
3649     } catch (...) {
3650       {
3651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3652       };
3653     }
3654   }
3655
3656   jresult = result;
3657   return jresult;
3658 }
3659
3660
3661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3662   void * jresult ;
3663   Dali::Any *result = 0 ;
3664
3665   {
3666     try {
3667       result = (Dali::Any *)new Dali::Any();
3668     } catch (std::out_of_range& e) {
3669       {
3670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3671       };
3672     } catch (std::exception& e) {
3673       {
3674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3675       };
3676     } catch (Dali::DaliException e) {
3677       {
3678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3679       };
3680     } catch (...) {
3681       {
3682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3683       };
3684     }
3685   }
3686
3687   jresult = (void *)result;
3688   return jresult;
3689 }
3690
3691
3692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3693   Dali::Any *arg1 = (Dali::Any *) 0 ;
3694
3695   arg1 = (Dali::Any *)jarg1;
3696   {
3697     try {
3698       delete arg1;
3699     } catch (std::out_of_range& e) {
3700       {
3701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3702       };
3703     } catch (std::exception& e) {
3704       {
3705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3706       };
3707     } catch (Dali::DaliException e) {
3708       {
3709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3710       };
3711     } catch (...) {
3712       {
3713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3714       };
3715     }
3716   }
3717
3718 }
3719
3720
3721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3722   char *arg1 = (char *) 0 ;
3723
3724   arg1 = (char *)jarg1;
3725   {
3726     try {
3727       Dali::Any::AssertAlways((char const *)arg1);
3728     } catch (std::out_of_range& e) {
3729       {
3730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3731       };
3732     } catch (std::exception& e) {
3733       {
3734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3735       };
3736     } catch (Dali::DaliException e) {
3737       {
3738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3739       };
3740     } catch (...) {
3741       {
3742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3743       };
3744     }
3745   }
3746
3747 }
3748
3749
3750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3751   void * jresult ;
3752   Dali::Any *arg1 = 0 ;
3753   Dali::Any *result = 0 ;
3754
3755   arg1 = (Dali::Any *)jarg1;
3756   if (!arg1) {
3757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3758     return 0;
3759   }
3760   {
3761     try {
3762       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3763     } catch (std::out_of_range& e) {
3764       {
3765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3766       };
3767     } catch (std::exception& e) {
3768       {
3769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3770       };
3771     } catch (Dali::DaliException e) {
3772       {
3773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3774       };
3775     } catch (...) {
3776       {
3777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3778       };
3779     }
3780   }
3781
3782   jresult = (void *)result;
3783   return jresult;
3784 }
3785
3786
3787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3788   void * jresult ;
3789   Dali::Any *arg1 = (Dali::Any *) 0 ;
3790   Dali::Any *arg2 = 0 ;
3791   Dali::Any *result = 0 ;
3792
3793   arg1 = (Dali::Any *)jarg1;
3794   arg2 = (Dali::Any *)jarg2;
3795   if (!arg2) {
3796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3797     return 0;
3798   }
3799   {
3800     try {
3801       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3802     } catch (std::out_of_range& e) {
3803       {
3804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3805       };
3806     } catch (std::exception& e) {
3807       {
3808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3809       };
3810     } catch (Dali::DaliException e) {
3811       {
3812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3813       };
3814     } catch (...) {
3815       {
3816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3817       };
3818     }
3819   }
3820
3821   jresult = (void *)result;
3822   return jresult;
3823 }
3824
3825
3826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3827   void * jresult ;
3828   Dali::Any *arg1 = (Dali::Any *) 0 ;
3829   std::type_info *result = 0 ;
3830
3831   arg1 = (Dali::Any *)jarg1;
3832   {
3833     try {
3834       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3835     } catch (std::out_of_range& e) {
3836       {
3837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3838       };
3839     } catch (std::exception& e) {
3840       {
3841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3842       };
3843     } catch (Dali::DaliException e) {
3844       {
3845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3846       };
3847     } catch (...) {
3848       {
3849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3850       };
3851     }
3852   }
3853
3854   jresult = (void *)result;
3855   return jresult;
3856 }
3857
3858
3859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3860   unsigned int jresult ;
3861   Dali::Any *arg1 = (Dali::Any *) 0 ;
3862   bool result;
3863
3864   arg1 = (Dali::Any *)jarg1;
3865   {
3866     try {
3867       result = (bool)((Dali::Any const *)arg1)->Empty();
3868     } catch (std::out_of_range& e) {
3869       {
3870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3871       };
3872     } catch (std::exception& e) {
3873       {
3874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3875       };
3876     } catch (Dali::DaliException e) {
3877       {
3878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3879       };
3880     } catch (...) {
3881       {
3882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3883       };
3884     }
3885   }
3886
3887   jresult = result;
3888   return jresult;
3889 }
3890
3891
3892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3893   void * jresult ;
3894   std::type_info *arg1 = 0 ;
3895   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3896   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3897   Dali::Any::AnyContainerBase *result = 0 ;
3898
3899   arg1 = (std::type_info *)jarg1;
3900   if (!arg1) {
3901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3902     return 0;
3903   }
3904   arg2 = (Dali::Any::CloneFunc)jarg2;
3905   arg3 = (Dali::Any::DeleteFunc)jarg3;
3906   {
3907     try {
3908       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3909     } catch (std::out_of_range& e) {
3910       {
3911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3912       };
3913     } catch (std::exception& e) {
3914       {
3915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3916       };
3917     } catch (Dali::DaliException e) {
3918       {
3919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3920       };
3921     } catch (...) {
3922       {
3923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3924       };
3925     }
3926   }
3927
3928   jresult = (void *)result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3934   void * jresult ;
3935   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3936   std::type_info *result = 0 ;
3937
3938   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3939   {
3940     try {
3941       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3942     } catch (std::out_of_range& e) {
3943       {
3944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3945       };
3946     } catch (std::exception& e) {
3947       {
3948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3949       };
3950     } catch (Dali::DaliException e) {
3951       {
3952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3953       };
3954     } catch (...) {
3955       {
3956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3957       };
3958     }
3959   }
3960
3961   jresult = (void *)result;
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3967   void * jresult ;
3968   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3969   ::std::type_info *result = 0 ;
3970
3971   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3972   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3973   jresult = (void *)result;
3974   return jresult;
3975 }
3976
3977
3978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3979   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3980   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3981
3982   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3983   arg2 = (Dali::Any::CloneFunc)jarg2;
3984   if (arg1) (arg1)->mCloneFunc = arg2;
3985 }
3986
3987
3988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3989   void * jresult ;
3990   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3991   Dali::Any::CloneFunc result;
3992
3993   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3994   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3995   jresult = (void *)result;
3996   return jresult;
3997 }
3998
3999
4000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4001   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4002   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4003
4004   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4005   arg2 = (Dali::Any::DeleteFunc)jarg2;
4006   if (arg1) (arg1)->mDeleteFunc = arg2;
4007 }
4008
4009
4010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4011   void * jresult ;
4012   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4013   Dali::Any::DeleteFunc result;
4014
4015   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4016   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4017   jresult = (void *)result;
4018   return jresult;
4019 }
4020
4021
4022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4023   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4024
4025   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4026   {
4027     try {
4028       delete arg1;
4029     } catch (std::out_of_range& e) {
4030       {
4031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4032       };
4033     } catch (std::exception& e) {
4034       {
4035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4036       };
4037     } catch (Dali::DaliException e) {
4038       {
4039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4040       };
4041     } catch (...) {
4042       {
4043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4044       };
4045     }
4046   }
4047
4048 }
4049
4050
4051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4052   Dali::Any *arg1 = (Dali::Any *) 0 ;
4053   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4054
4055   arg1 = (Dali::Any *)jarg1;
4056   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4057   if (arg1) (arg1)->mContainer = arg2;
4058 }
4059
4060
4061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4062   void * jresult ;
4063   Dali::Any *arg1 = (Dali::Any *) 0 ;
4064   Dali::Any::AnyContainerBase *result = 0 ;
4065
4066   arg1 = (Dali::Any *)jarg1;
4067   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4068   jresult = (void *)result;
4069   return jresult;
4070 }
4071
4072
4073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4074   char *arg1 = (char *) 0 ;
4075   char *arg2 = (char *) 0 ;
4076
4077   arg1 = (char *)jarg1;
4078   arg2 = (char *)jarg2;
4079   {
4080     try {
4081       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4082     } catch (std::out_of_range& e) {
4083       {
4084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4085       };
4086     } catch (std::exception& e) {
4087       {
4088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4089       };
4090     } catch (Dali::DaliException e) {
4091       {
4092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4093       };
4094     } catch (...) {
4095       {
4096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4097       };
4098     }
4099   }
4100
4101 }
4102
4103
4104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4105   void * jresult ;
4106   char *arg1 = (char *) 0 ;
4107   char *arg2 = (char *) 0 ;
4108   Dali::DaliException *result = 0 ;
4109
4110   arg1 = (char *)jarg1;
4111   arg2 = (char *)jarg2;
4112   {
4113     try {
4114       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4115     } catch (std::out_of_range& e) {
4116       {
4117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4118       };
4119     } catch (std::exception& e) {
4120       {
4121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4122       };
4123     } catch (Dali::DaliException e) {
4124       {
4125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4126       };
4127     } catch (...) {
4128       {
4129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4130       };
4131     }
4132   }
4133
4134   jresult = (void *)result;
4135   return jresult;
4136 }
4137
4138
4139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4140   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4141   std::string arg2 = std::string(jarg2);
4142
4143   arg1 = (Dali::DaliException *)jarg1;
4144   {
4145     if (!arg2.empty()) {
4146       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4147     } else {
4148       arg1->location = 0;
4149     }
4150   }
4151 }
4152
4153 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4154   char * jresult ;
4155   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4156   char *result = 0 ;
4157
4158   arg1 = (Dali::DaliException *)jarg1;
4159   result = (char *) ((arg1)->location);
4160   jresult = SWIG_csharp_string_callback((const char *)result);
4161   return jresult;
4162 }
4163
4164
4165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4166   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4167   std::string arg2 = std::string(jarg2);
4168
4169   arg1 = (Dali::DaliException *)jarg1;
4170   {
4171     if (!arg2.empty()) {
4172       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4173     } else {
4174       arg1->condition = 0;
4175     }
4176   }
4177 }
4178
4179
4180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4181   char * jresult ;
4182   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4183   char *result = 0 ;
4184
4185   arg1 = (Dali::DaliException *)jarg1;
4186   result = (char *) ((arg1)->condition);
4187   jresult = SWIG_csharp_string_callback((const char *)result);
4188   return jresult;
4189 }
4190
4191
4192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4193   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4194
4195   arg1 = (Dali::DaliException *)jarg1;
4196   {
4197     try {
4198       delete arg1;
4199     } catch (std::out_of_range& e) {
4200       {
4201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4202       };
4203     } catch (std::exception& e) {
4204       {
4205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4206       };
4207     } catch (Dali::DaliException e) {
4208       {
4209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4210       };
4211     } catch (...) {
4212       {
4213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4214       };
4215     }
4216   }
4217
4218 }
4219
4220
4221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4222   void * jresult ;
4223   Dali::Vector2 *result = 0 ;
4224
4225   {
4226     try {
4227       result = (Dali::Vector2 *)new Dali::Vector2();
4228     } catch (std::out_of_range& e) {
4229       {
4230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4231       };
4232     } catch (std::exception& e) {
4233       {
4234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4235       };
4236     } catch (Dali::DaliException e) {
4237       {
4238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4239       };
4240     } catch (...) {
4241       {
4242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4243       };
4244     }
4245   }
4246
4247   jresult = (void *)result;
4248   return jresult;
4249 }
4250
4251
4252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4253   void * jresult ;
4254   float arg1 ;
4255   float arg2 ;
4256   Dali::Vector2 *result = 0 ;
4257
4258   arg1 = (float)jarg1;
4259   arg2 = (float)jarg2;
4260   {
4261     try {
4262       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4263     } catch (std::out_of_range& e) {
4264       {
4265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4266       };
4267     } catch (std::exception& e) {
4268       {
4269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4270       };
4271     } catch (Dali::DaliException e) {
4272       {
4273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4274       };
4275     } catch (...) {
4276       {
4277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4278       };
4279     }
4280   }
4281
4282   jresult = (void *)result;
4283   return jresult;
4284 }
4285
4286
4287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4288   void * jresult ;
4289   float *arg1 = (float *) 0 ;
4290   Dali::Vector2 *result = 0 ;
4291
4292   arg1 = jarg1;
4293   {
4294     try {
4295       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4296     } catch (std::out_of_range& e) {
4297       {
4298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4299       };
4300     } catch (std::exception& e) {
4301       {
4302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4303       };
4304     } catch (Dali::DaliException e) {
4305       {
4306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4307       };
4308     } catch (...) {
4309       {
4310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4311       };
4312     }
4313   }
4314
4315   jresult = (void *)result;
4316
4317
4318   return jresult;
4319 }
4320
4321
4322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4323   void * jresult ;
4324   Dali::Vector3 *arg1 = 0 ;
4325   Dali::Vector2 *result = 0 ;
4326
4327   arg1 = (Dali::Vector3 *)jarg1;
4328   if (!arg1) {
4329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4330     return 0;
4331   }
4332   {
4333     try {
4334       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4335     } catch (std::out_of_range& e) {
4336       {
4337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4338       };
4339     } catch (std::exception& e) {
4340       {
4341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4342       };
4343     } catch (Dali::DaliException e) {
4344       {
4345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4346       };
4347     } catch (...) {
4348       {
4349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4350       };
4351     }
4352   }
4353
4354   jresult = (void *)result;
4355   return jresult;
4356 }
4357
4358
4359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4360   void * jresult ;
4361   Dali::Vector4 *arg1 = 0 ;
4362   Dali::Vector2 *result = 0 ;
4363
4364   arg1 = (Dali::Vector4 *)jarg1;
4365   if (!arg1) {
4366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4367     return 0;
4368   }
4369   {
4370     try {
4371       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4372     } catch (std::out_of_range& e) {
4373       {
4374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4375       };
4376     } catch (std::exception& e) {
4377       {
4378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4379       };
4380     } catch (Dali::DaliException e) {
4381       {
4382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4383       };
4384     } catch (...) {
4385       {
4386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4387       };
4388     }
4389   }
4390
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4427   void * jresult ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4431   jresult = (void *)result;
4432   return jresult;
4433 }
4434
4435
4436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4437   void * jresult ;
4438   Dali::Vector2 *result = 0 ;
4439
4440   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4441   jresult = (void *)result;
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4447   void * jresult ;
4448   Dali::Vector2 *result = 0 ;
4449
4450   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4451   jresult = (void *)result;
4452   return jresult;
4453 }
4454
4455
4456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4457   void * jresult ;
4458   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4459   float *arg2 = (float *) 0 ;
4460   Dali::Vector2 *result = 0 ;
4461
4462   arg1 = (Dali::Vector2 *)jarg1;
4463   arg2 = jarg2;
4464   {
4465     try {
4466       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4467     } catch (std::out_of_range& e) {
4468       {
4469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4470       };
4471     } catch (std::exception& e) {
4472       {
4473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4474       };
4475     } catch (Dali::DaliException e) {
4476       {
4477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4478       };
4479     } catch (...) {
4480       {
4481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4482       };
4483     }
4484   }
4485
4486   jresult = (void *)result;
4487
4488
4489   return jresult;
4490 }
4491
4492
4493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4494   void * jresult ;
4495   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4496   Dali::Vector3 *arg2 = 0 ;
4497   Dali::Vector2 *result = 0 ;
4498
4499   arg1 = (Dali::Vector2 *)jarg1;
4500   arg2 = (Dali::Vector3 *)jarg2;
4501   if (!arg2) {
4502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4503     return 0;
4504   }
4505   {
4506     try {
4507       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4508     } catch (std::out_of_range& e) {
4509       {
4510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4511       };
4512     } catch (std::exception& e) {
4513       {
4514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4515       };
4516     } catch (Dali::DaliException e) {
4517       {
4518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4519       };
4520     } catch (...) {
4521       {
4522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4523       };
4524     }
4525   }
4526
4527   jresult = (void *)result;
4528   return jresult;
4529 }
4530
4531
4532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4533   void * jresult ;
4534   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4535   Dali::Vector4 *arg2 = 0 ;
4536   Dali::Vector2 *result = 0 ;
4537
4538   arg1 = (Dali::Vector2 *)jarg1;
4539   arg2 = (Dali::Vector4 *)jarg2;
4540   if (!arg2) {
4541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4542     return 0;
4543   }
4544   {
4545     try {
4546       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4547     } catch (std::out_of_range& e) {
4548       {
4549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4550       };
4551     } catch (std::exception& e) {
4552       {
4553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (Dali::DaliException e) {
4556       {
4557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4558       };
4559     } catch (...) {
4560       {
4561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4562       };
4563     }
4564   }
4565
4566   jresult = (void *)result;
4567   return jresult;
4568 }
4569
4570
4571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4572   void * jresult ;
4573   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4574   Dali::Vector2 *arg2 = 0 ;
4575   Dali::Vector2 result;
4576
4577   arg1 = (Dali::Vector2 *)jarg1;
4578   arg2 = (Dali::Vector2 *)jarg2;
4579   if (!arg2) {
4580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4581     return 0;
4582   }
4583   {
4584     try {
4585       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4586     } catch (std::out_of_range& e) {
4587       {
4588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4589       };
4590     } catch (std::exception& e) {
4591       {
4592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4593       };
4594     } catch (Dali::DaliException e) {
4595       {
4596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4597       };
4598     } catch (...) {
4599       {
4600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4601       };
4602     }
4603   }
4604
4605   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4606   return jresult;
4607 }
4608
4609
4610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4611   void * jresult ;
4612   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4613   Dali::Vector2 *arg2 = 0 ;
4614   Dali::Vector2 *result = 0 ;
4615
4616   arg1 = (Dali::Vector2 *)jarg1;
4617   arg2 = (Dali::Vector2 *)jarg2;
4618   if (!arg2) {
4619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4620     return 0;
4621   }
4622   {
4623     try {
4624       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4625     } catch (std::out_of_range& e) {
4626       {
4627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4628       };
4629     } catch (std::exception& e) {
4630       {
4631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4632       };
4633     } catch (Dali::DaliException e) {
4634       {
4635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4636       };
4637     } catch (...) {
4638       {
4639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4640       };
4641     }
4642   }
4643
4644   jresult = (void *)result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4650   void * jresult ;
4651   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4652   Dali::Vector2 *arg2 = 0 ;
4653   Dali::Vector2 result;
4654
4655   arg1 = (Dali::Vector2 *)jarg1;
4656   arg2 = (Dali::Vector2 *)jarg2;
4657   if (!arg2) {
4658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4659     return 0;
4660   }
4661   {
4662     try {
4663       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4664     } catch (std::out_of_range& e) {
4665       {
4666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4667       };
4668     } catch (std::exception& e) {
4669       {
4670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4671       };
4672     } catch (Dali::DaliException e) {
4673       {
4674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4675       };
4676     } catch (...) {
4677       {
4678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4679       };
4680     }
4681   }
4682
4683   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4684   return jresult;
4685 }
4686
4687
4688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4689   void * jresult ;
4690   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4691   Dali::Vector2 *arg2 = 0 ;
4692   Dali::Vector2 *result = 0 ;
4693
4694   arg1 = (Dali::Vector2 *)jarg1;
4695   arg2 = (Dali::Vector2 *)jarg2;
4696   if (!arg2) {
4697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4698     return 0;
4699   }
4700   {
4701     try {
4702       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4703     } catch (std::out_of_range& e) {
4704       {
4705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4706       };
4707     } catch (std::exception& e) {
4708       {
4709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4710       };
4711     } catch (Dali::DaliException e) {
4712       {
4713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4714       };
4715     } catch (...) {
4716       {
4717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4718       };
4719     }
4720   }
4721
4722   jresult = (void *)result;
4723   return jresult;
4724 }
4725
4726
4727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4728   void * jresult ;
4729   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4730   Dali::Vector2 *arg2 = 0 ;
4731   Dali::Vector2 result;
4732
4733   arg1 = (Dali::Vector2 *)jarg1;
4734   arg2 = (Dali::Vector2 *)jarg2;
4735   if (!arg2) {
4736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4737     return 0;
4738   }
4739   {
4740     try {
4741       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4742     } catch (std::out_of_range& e) {
4743       {
4744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4745       };
4746     } catch (std::exception& e) {
4747       {
4748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4749       };
4750     } catch (Dali::DaliException e) {
4751       {
4752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4753       };
4754     } catch (...) {
4755       {
4756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4757       };
4758     }
4759   }
4760
4761   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4762   return jresult;
4763 }
4764
4765
4766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4767   void * jresult ;
4768   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4769   float arg2 ;
4770   Dali::Vector2 result;
4771
4772   arg1 = (Dali::Vector2 *)jarg1;
4773   arg2 = (float)jarg2;
4774   {
4775     try {
4776       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4777     } catch (std::out_of_range& e) {
4778       {
4779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4780       };
4781     } catch (std::exception& e) {
4782       {
4783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4784       };
4785     } catch (Dali::DaliException e) {
4786       {
4787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4788       };
4789     } catch (...) {
4790       {
4791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4792       };
4793     }
4794   }
4795
4796   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4797   return jresult;
4798 }
4799
4800
4801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4802   void * jresult ;
4803   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4804   Dali::Vector2 *arg2 = 0 ;
4805   Dali::Vector2 *result = 0 ;
4806
4807   arg1 = (Dali::Vector2 *)jarg1;
4808   arg2 = (Dali::Vector2 *)jarg2;
4809   if (!arg2) {
4810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4811     return 0;
4812   }
4813   {
4814     try {
4815       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4816     } catch (std::out_of_range& e) {
4817       {
4818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4819       };
4820     } catch (std::exception& e) {
4821       {
4822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4823       };
4824     } catch (Dali::DaliException e) {
4825       {
4826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4827       };
4828     } catch (...) {
4829       {
4830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4831       };
4832     }
4833   }
4834
4835   jresult = (void *)result;
4836   return jresult;
4837 }
4838
4839
4840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4841   void * jresult ;
4842   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4843   float arg2 ;
4844   Dali::Vector2 *result = 0 ;
4845
4846   arg1 = (Dali::Vector2 *)jarg1;
4847   arg2 = (float)jarg2;
4848   {
4849     try {
4850       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4851     } catch (std::out_of_range& e) {
4852       {
4853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4854       };
4855     } catch (std::exception& e) {
4856       {
4857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4858       };
4859     } catch (Dali::DaliException e) {
4860       {
4861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4862       };
4863     } catch (...) {
4864       {
4865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4866       };
4867     }
4868   }
4869
4870   jresult = (void *)result;
4871   return jresult;
4872 }
4873
4874
4875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4876   void * jresult ;
4877   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4878   Dali::Vector2 *arg2 = 0 ;
4879   Dali::Vector2 result;
4880
4881   arg1 = (Dali::Vector2 *)jarg1;
4882   arg2 = (Dali::Vector2 *)jarg2;
4883   if (!arg2) {
4884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4885     return 0;
4886   }
4887   {
4888     try {
4889       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4890     } catch (std::out_of_range& e) {
4891       {
4892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4893       };
4894     } catch (std::exception& e) {
4895       {
4896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4897       };
4898     } catch (Dali::DaliException e) {
4899       {
4900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4901       };
4902     } catch (...) {
4903       {
4904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4905       };
4906     }
4907   }
4908
4909   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4910   return jresult;
4911 }
4912
4913
4914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4915   void * jresult ;
4916   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4917   float arg2 ;
4918   Dali::Vector2 result;
4919
4920   arg1 = (Dali::Vector2 *)jarg1;
4921   arg2 = (float)jarg2;
4922   {
4923     try {
4924       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4925     } catch (std::out_of_range& e) {
4926       {
4927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4928       };
4929     } catch (std::exception& e) {
4930       {
4931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4932       };
4933     } catch (Dali::DaliException e) {
4934       {
4935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4936       };
4937     } catch (...) {
4938       {
4939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4940       };
4941     }
4942   }
4943
4944   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4945   return jresult;
4946 }
4947
4948
4949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4950   void * jresult ;
4951   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4952   Dali::Vector2 *arg2 = 0 ;
4953   Dali::Vector2 *result = 0 ;
4954
4955   arg1 = (Dali::Vector2 *)jarg1;
4956   arg2 = (Dali::Vector2 *)jarg2;
4957   if (!arg2) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4959     return 0;
4960   }
4961   {
4962     try {
4963       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4964     } catch (std::out_of_range& e) {
4965       {
4966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4967       };
4968     } catch (std::exception& e) {
4969       {
4970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4971       };
4972     } catch (Dali::DaliException e) {
4973       {
4974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4975       };
4976     } catch (...) {
4977       {
4978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4979       };
4980     }
4981   }
4982
4983   jresult = (void *)result;
4984   return jresult;
4985 }
4986
4987
4988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4989   void * jresult ;
4990   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4991   float arg2 ;
4992   Dali::Vector2 *result = 0 ;
4993
4994   arg1 = (Dali::Vector2 *)jarg1;
4995   arg2 = (float)jarg2;
4996   {
4997     try {
4998       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4999     } catch (std::out_of_range& e) {
5000       {
5001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5002       };
5003     } catch (std::exception& e) {
5004       {
5005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5006       };
5007     } catch (Dali::DaliException e) {
5008       {
5009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5010       };
5011     } catch (...) {
5012       {
5013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5014       };
5015     }
5016   }
5017
5018   jresult = (void *)result;
5019   return jresult;
5020 }
5021
5022
5023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5024   void * jresult ;
5025   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5026   Dali::Vector2 result;
5027
5028   arg1 = (Dali::Vector2 *)jarg1;
5029   {
5030     try {
5031       result = ((Dali::Vector2 const *)arg1)->operator -();
5032     } catch (std::out_of_range& e) {
5033       {
5034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (std::exception& e) {
5037       {
5038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5039       };
5040     } catch (Dali::DaliException e) {
5041       {
5042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5043       };
5044     } catch (...) {
5045       {
5046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5047       };
5048     }
5049   }
5050
5051   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5052   return jresult;
5053 }
5054
5055
5056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5057   unsigned int jresult ;
5058   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5059   Dali::Vector2 *arg2 = 0 ;
5060   bool result;
5061
5062   arg1 = (Dali::Vector2 *)jarg1;
5063   arg2 = (Dali::Vector2 *)jarg2;
5064   if (!arg2) {
5065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5066     return 0;
5067   }
5068   {
5069     try {
5070       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (Dali::DaliException e) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5082       };
5083     } catch (...) {
5084       {
5085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5086       };
5087     }
5088   }
5089
5090   jresult = result;
5091   return jresult;
5092 }
5093
5094
5095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5096   unsigned int jresult ;
5097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5098   Dali::Vector2 *arg2 = 0 ;
5099   bool result;
5100
5101   arg1 = (Dali::Vector2 *)jarg1;
5102   arg2 = (Dali::Vector2 *)jarg2;
5103   if (!arg2) {
5104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5105     return 0;
5106   }
5107   {
5108     try {
5109       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5110     } catch (std::out_of_range& e) {
5111       {
5112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5113       };
5114     } catch (std::exception& e) {
5115       {
5116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5117       };
5118     } catch (Dali::DaliException e) {
5119       {
5120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5121       };
5122     } catch (...) {
5123       {
5124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5125       };
5126     }
5127   }
5128
5129   jresult = result;
5130   return jresult;
5131 }
5132
5133
5134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5135   float jresult ;
5136   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5137   unsigned int arg2 ;
5138   float *result = 0 ;
5139
5140   arg1 = (Dali::Vector2 *)jarg1;
5141   arg2 = (unsigned int)jarg2;
5142   {
5143     try {
5144       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5145     } catch (std::out_of_range& e) {
5146       {
5147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5148       };
5149     } catch (std::exception& e) {
5150       {
5151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5152       };
5153     } catch (Dali::DaliException e) {
5154       {
5155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5156       };
5157     } catch (...) {
5158       {
5159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5160       };
5161     }
5162   }
5163
5164   jresult = *result;
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5170   float jresult ;
5171   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5172   float result;
5173
5174   arg1 = (Dali::Vector2 *)jarg1;
5175   {
5176     try {
5177       result = (float)((Dali::Vector2 const *)arg1)->Length();
5178     } catch (std::out_of_range& e) {
5179       {
5180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5181       };
5182     } catch (std::exception& e) {
5183       {
5184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5185       };
5186     } catch (Dali::DaliException e) {
5187       {
5188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5189       };
5190     } catch (...) {
5191       {
5192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5193       };
5194     }
5195   }
5196
5197   jresult = result;
5198   return jresult;
5199 }
5200
5201
5202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5203   float jresult ;
5204   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5205   float result;
5206
5207   arg1 = (Dali::Vector2 *)jarg1;
5208   {
5209     try {
5210       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5211     } catch (std::out_of_range& e) {
5212       {
5213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5214       };
5215     } catch (std::exception& e) {
5216       {
5217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5218       };
5219     } catch (Dali::DaliException e) {
5220       {
5221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5222       };
5223     } catch (...) {
5224       {
5225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5226       };
5227     }
5228   }
5229
5230   jresult = result;
5231   return jresult;
5232 }
5233
5234
5235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5236   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5237
5238   arg1 = (Dali::Vector2 *)jarg1;
5239   {
5240     try {
5241       (arg1)->Normalize();
5242     } catch (std::out_of_range& e) {
5243       {
5244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5245       };
5246     } catch (std::exception& e) {
5247       {
5248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5249       };
5250     } catch (Dali::DaliException e) {
5251       {
5252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5253       };
5254     } catch (...) {
5255       {
5256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5257       };
5258     }
5259   }
5260
5261 }
5262
5263
5264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5265   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5266   Dali::Vector2 *arg2 = 0 ;
5267   Dali::Vector2 *arg3 = 0 ;
5268
5269   arg1 = (Dali::Vector2 *)jarg1;
5270   arg2 = (Dali::Vector2 *)jarg2;
5271   if (!arg2) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5273     return ;
5274   }
5275   arg3 = (Dali::Vector2 *)jarg3;
5276   if (!arg3) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5278     return ;
5279   }
5280   {
5281     try {
5282       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5283     } catch (std::out_of_range& e) {
5284       {
5285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5286       };
5287     } catch (std::exception& e) {
5288       {
5289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5290       };
5291     } catch (Dali::DaliException e) {
5292       {
5293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5294       };
5295     } catch (...) {
5296       {
5297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5298       };
5299     }
5300   }
5301
5302 }
5303
5304
5305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5306   void * jresult ;
5307   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5308   float *result = 0 ;
5309
5310   arg1 = (Dali::Vector2 *)jarg1;
5311   {
5312     try {
5313       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5314     } catch (std::out_of_range& e) {
5315       {
5316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5317       };
5318     } catch (std::exception& e) {
5319       {
5320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5321       };
5322     } catch (Dali::DaliException e) {
5323       {
5324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5325       };
5326     } catch (...) {
5327       {
5328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5329       };
5330     }
5331   }
5332
5333   jresult = (void *)result;
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5339   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5340   float arg2 ;
5341
5342   arg1 = (Dali::Vector2 *)jarg1;
5343   arg2 = (float)jarg2;
5344   if (arg1) (arg1)->x = arg2;
5345 }
5346
5347
5348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5349   float jresult ;
5350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5351   float result;
5352
5353   arg1 = (Dali::Vector2 *)jarg1;
5354   result = (float) ((arg1)->x);
5355   jresult = result;
5356   return jresult;
5357 }
5358
5359
5360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5362   float arg2 ;
5363
5364   arg1 = (Dali::Vector2 *)jarg1;
5365   arg2 = (float)jarg2;
5366   if (arg1) (arg1)->width = arg2;
5367 }
5368
5369
5370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5371   float jresult ;
5372   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5373   float result;
5374
5375   arg1 = (Dali::Vector2 *)jarg1;
5376   result = (float) ((arg1)->width);
5377   jresult = result;
5378   return jresult;
5379 }
5380
5381
5382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5383   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5384   float arg2 ;
5385
5386   arg1 = (Dali::Vector2 *)jarg1;
5387   arg2 = (float)jarg2;
5388   if (arg1) (arg1)->y = arg2;
5389 }
5390
5391
5392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5393   float jresult ;
5394   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5395   float result;
5396
5397   arg1 = (Dali::Vector2 *)jarg1;
5398   result = (float) ((arg1)->y);
5399   jresult = result;
5400   return jresult;
5401 }
5402
5403
5404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5405   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5406   float arg2 ;
5407
5408   arg1 = (Dali::Vector2 *)jarg1;
5409   arg2 = (float)jarg2;
5410   if (arg1) (arg1)->height = arg2;
5411 }
5412
5413
5414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5415   float jresult ;
5416   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5417   float result;
5418
5419   arg1 = (Dali::Vector2 *)jarg1;
5420   result = (float) ((arg1)->height);
5421   jresult = result;
5422   return jresult;
5423 }
5424
5425
5426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5427   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5428
5429   arg1 = (Dali::Vector2 *)jarg1;
5430   {
5431     try {
5432       delete arg1;
5433     } catch (std::out_of_range& e) {
5434       {
5435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5436       };
5437     } catch (std::exception& e) {
5438       {
5439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5440       };
5441     } catch (Dali::DaliException e) {
5442       {
5443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5444       };
5445     } catch (...) {
5446       {
5447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5448       };
5449     }
5450   }
5451
5452 }
5453
5454
5455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5456   void * jresult ;
5457   Dali::Vector2 *arg1 = 0 ;
5458   Dali::Vector2 *arg2 = 0 ;
5459   Dali::Vector2 result;
5460
5461   arg1 = (Dali::Vector2 *)jarg1;
5462   if (!arg1) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5464     return 0;
5465   }
5466   arg2 = (Dali::Vector2 *)jarg2;
5467   if (!arg2) {
5468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5469     return 0;
5470   }
5471   {
5472     try {
5473       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5474     } catch (std::out_of_range& e) {
5475       {
5476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5477       };
5478     } catch (std::exception& e) {
5479       {
5480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5481       };
5482     } catch (Dali::DaliException e) {
5483       {
5484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5485       };
5486     } catch (...) {
5487       {
5488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5489       };
5490     }
5491   }
5492
5493   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5494   return jresult;
5495 }
5496
5497
5498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5499   void * jresult ;
5500   Dali::Vector2 *arg1 = 0 ;
5501   Dali::Vector2 *arg2 = 0 ;
5502   Dali::Vector2 result;
5503
5504   arg1 = (Dali::Vector2 *)jarg1;
5505   if (!arg1) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   arg2 = (Dali::Vector2 *)jarg2;
5510   if (!arg2) {
5511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5512     return 0;
5513   }
5514   {
5515     try {
5516       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (Dali::DaliException e) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5528       };
5529     } catch (...) {
5530       {
5531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5532       };
5533     }
5534   }
5535
5536   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5537   return jresult;
5538 }
5539
5540
5541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5542   void * jresult ;
5543   Dali::Vector2 *arg1 = 0 ;
5544   float *arg2 = 0 ;
5545   float *arg3 = 0 ;
5546   float temp2 ;
5547   float temp3 ;
5548   Dali::Vector2 result;
5549
5550   arg1 = (Dali::Vector2 *)jarg1;
5551   if (!arg1) {
5552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5553     return 0;
5554   }
5555   temp2 = (float)jarg2;
5556   arg2 = &temp2;
5557   temp3 = (float)jarg3;
5558   arg3 = &temp3;
5559   {
5560     try {
5561       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5562     } catch (std::out_of_range& e) {
5563       {
5564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5565       };
5566     } catch (std::exception& e) {
5567       {
5568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5569       };
5570     } catch (Dali::DaliException e) {
5571       {
5572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5573       };
5574     } catch (...) {
5575       {
5576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5577       };
5578     }
5579   }
5580
5581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5582   return jresult;
5583 }
5584
5585
5586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5587   void * jresult ;
5588   Dali::Vector3 *result = 0 ;
5589
5590   {
5591     try {
5592       result = (Dali::Vector3 *)new Dali::Vector3();
5593     } catch (std::out_of_range& e) {
5594       {
5595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5596       };
5597     } catch (std::exception& e) {
5598       {
5599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5600       };
5601     } catch (Dali::DaliException e) {
5602       {
5603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5604       };
5605     } catch (...) {
5606       {
5607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5608       };
5609     }
5610   }
5611
5612   jresult = (void *)result;
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5618   void * jresult ;
5619   float arg1 ;
5620   float arg2 ;
5621   float arg3 ;
5622   Dali::Vector3 *result = 0 ;
5623
5624   arg1 = (float)jarg1;
5625   arg2 = (float)jarg2;
5626   arg3 = (float)jarg3;
5627   {
5628     try {
5629       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5630     } catch (std::out_of_range& e) {
5631       {
5632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5633       };
5634     } catch (std::exception& e) {
5635       {
5636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (Dali::DaliException e) {
5639       {
5640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5641       };
5642     } catch (...) {
5643       {
5644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5645       };
5646     }
5647   }
5648
5649   jresult = (void *)result;
5650   return jresult;
5651 }
5652
5653
5654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5655   void * jresult ;
5656   float *arg1 = (float *) 0 ;
5657   Dali::Vector3 *result = 0 ;
5658
5659   arg1 = jarg1;
5660   {
5661     try {
5662       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5663     } catch (std::out_of_range& e) {
5664       {
5665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5666       };
5667     } catch (std::exception& e) {
5668       {
5669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5670       };
5671     } catch (Dali::DaliException e) {
5672       {
5673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5674       };
5675     } catch (...) {
5676       {
5677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5678       };
5679     }
5680   }
5681
5682   jresult = (void *)result;
5683
5684
5685   return jresult;
5686 }
5687
5688
5689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5690   void * jresult ;
5691   Dali::Vector2 *arg1 = 0 ;
5692   Dali::Vector3 *result = 0 ;
5693
5694   arg1 = (Dali::Vector2 *)jarg1;
5695   if (!arg1) {
5696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5697     return 0;
5698   }
5699   {
5700     try {
5701       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5702     } catch (std::out_of_range& e) {
5703       {
5704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5705       };
5706     } catch (std::exception& e) {
5707       {
5708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5709       };
5710     } catch (Dali::DaliException e) {
5711       {
5712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5713       };
5714     } catch (...) {
5715       {
5716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5717       };
5718     }
5719   }
5720
5721   jresult = (void *)result;
5722   return jresult;
5723 }
5724
5725
5726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5727   void * jresult ;
5728   Dali::Vector4 *arg1 = 0 ;
5729   Dali::Vector3 *result = 0 ;
5730
5731   arg1 = (Dali::Vector4 *)jarg1;
5732   if (!arg1) {
5733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5734     return 0;
5735   }
5736   {
5737     try {
5738       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (Dali::DaliException e) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5750       };
5751     } catch (...) {
5752       {
5753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5754       };
5755     }
5756   }
5757
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5814   void * jresult ;
5815   Dali::Vector3 *result = 0 ;
5816
5817   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5818   jresult = (void *)result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5824   void * jresult ;
5825   Dali::Vector3 *result = 0 ;
5826
5827   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5828   jresult = (void *)result;
5829   return jresult;
5830 }
5831
5832
5833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5834   void * jresult ;
5835   Dali::Vector3 *result = 0 ;
5836
5837   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5838   jresult = (void *)result;
5839   return jresult;
5840 }
5841
5842
5843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5844   void * jresult ;
5845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5846   float *arg2 = (float *) 0 ;
5847   Dali::Vector3 *result = 0 ;
5848
5849   arg1 = (Dali::Vector3 *)jarg1;
5850   arg2 = jarg2;
5851   {
5852     try {
5853       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5854     } catch (std::out_of_range& e) {
5855       {
5856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (std::exception& e) {
5859       {
5860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5861       };
5862     } catch (Dali::DaliException e) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5865       };
5866     } catch (...) {
5867       {
5868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5869       };
5870     }
5871   }
5872
5873   jresult = (void *)result;
5874
5875
5876   return jresult;
5877 }
5878
5879
5880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5881   void * jresult ;
5882   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5883   Dali::Vector2 *arg2 = 0 ;
5884   Dali::Vector3 *result = 0 ;
5885
5886   arg1 = (Dali::Vector3 *)jarg1;
5887   arg2 = (Dali::Vector2 *)jarg2;
5888   if (!arg2) {
5889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5890     return 0;
5891   }
5892   {
5893     try {
5894       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5895     } catch (std::out_of_range& e) {
5896       {
5897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5898       };
5899     } catch (std::exception& e) {
5900       {
5901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5902       };
5903     } catch (Dali::DaliException e) {
5904       {
5905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5906       };
5907     } catch (...) {
5908       {
5909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5910       };
5911     }
5912   }
5913
5914   jresult = (void *)result;
5915   return jresult;
5916 }
5917
5918
5919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5920   void * jresult ;
5921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5922   Dali::Vector4 *arg2 = 0 ;
5923   Dali::Vector3 *result = 0 ;
5924
5925   arg1 = (Dali::Vector3 *)jarg1;
5926   arg2 = (Dali::Vector4 *)jarg2;
5927   if (!arg2) {
5928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5929     return 0;
5930   }
5931   {
5932     try {
5933       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5934     } catch (std::out_of_range& e) {
5935       {
5936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5937       };
5938     } catch (std::exception& e) {
5939       {
5940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5941       };
5942     } catch (Dali::DaliException e) {
5943       {
5944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5945       };
5946     } catch (...) {
5947       {
5948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5949       };
5950     }
5951   }
5952
5953   jresult = (void *)result;
5954   return jresult;
5955 }
5956
5957
5958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5959   void * jresult ;
5960   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5961   Dali::Vector3 *arg2 = 0 ;
5962   Dali::Vector3 result;
5963
5964   arg1 = (Dali::Vector3 *)jarg1;
5965   arg2 = (Dali::Vector3 *)jarg2;
5966   if (!arg2) {
5967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5968     return 0;
5969   }
5970   {
5971     try {
5972       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5973     } catch (std::out_of_range& e) {
5974       {
5975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5976       };
5977     } catch (std::exception& e) {
5978       {
5979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5980       };
5981     } catch (Dali::DaliException e) {
5982       {
5983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5984       };
5985     } catch (...) {
5986       {
5987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5988       };
5989     }
5990   }
5991
5992   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5993   return jresult;
5994 }
5995
5996
5997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5998   void * jresult ;
5999   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6000   Dali::Vector3 *arg2 = 0 ;
6001   Dali::Vector3 *result = 0 ;
6002
6003   arg1 = (Dali::Vector3 *)jarg1;
6004   arg2 = (Dali::Vector3 *)jarg2;
6005   if (!arg2) {
6006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6007     return 0;
6008   }
6009   {
6010     try {
6011       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6012     } catch (std::out_of_range& e) {
6013       {
6014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6015       };
6016     } catch (std::exception& e) {
6017       {
6018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6019       };
6020     } catch (Dali::DaliException e) {
6021       {
6022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6023       };
6024     } catch (...) {
6025       {
6026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6027       };
6028     }
6029   }
6030
6031   jresult = (void *)result;
6032   return jresult;
6033 }
6034
6035
6036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6037   void * jresult ;
6038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6039   Dali::Vector3 *arg2 = 0 ;
6040   Dali::Vector3 result;
6041
6042   arg1 = (Dali::Vector3 *)jarg1;
6043   arg2 = (Dali::Vector3 *)jarg2;
6044   if (!arg2) {
6045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6046     return 0;
6047   }
6048   {
6049     try {
6050       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6051     } catch (std::out_of_range& e) {
6052       {
6053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6054       };
6055     } catch (std::exception& e) {
6056       {
6057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6058       };
6059     } catch (Dali::DaliException e) {
6060       {
6061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6062       };
6063     } catch (...) {
6064       {
6065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6066       };
6067     }
6068   }
6069
6070   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6071   return jresult;
6072 }
6073
6074
6075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6076   void * jresult ;
6077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6078   Dali::Vector3 *arg2 = 0 ;
6079   Dali::Vector3 *result = 0 ;
6080
6081   arg1 = (Dali::Vector3 *)jarg1;
6082   arg2 = (Dali::Vector3 *)jarg2;
6083   if (!arg2) {
6084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6085     return 0;
6086   }
6087   {
6088     try {
6089       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6090     } catch (std::out_of_range& e) {
6091       {
6092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6093       };
6094     } catch (std::exception& e) {
6095       {
6096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6097       };
6098     } catch (Dali::DaliException e) {
6099       {
6100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6101       };
6102     } catch (...) {
6103       {
6104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6105       };
6106     }
6107   }
6108
6109   jresult = (void *)result;
6110   return jresult;
6111 }
6112
6113
6114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6115   void * jresult ;
6116   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6117   Dali::Vector3 *arg2 = 0 ;
6118   Dali::Vector3 result;
6119
6120   arg1 = (Dali::Vector3 *)jarg1;
6121   arg2 = (Dali::Vector3 *)jarg2;
6122   if (!arg2) {
6123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6124     return 0;
6125   }
6126   {
6127     try {
6128       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6129     } catch (std::out_of_range& e) {
6130       {
6131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6132       };
6133     } catch (std::exception& e) {
6134       {
6135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6136       };
6137     } catch (Dali::DaliException e) {
6138       {
6139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6140       };
6141     } catch (...) {
6142       {
6143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6144       };
6145     }
6146   }
6147
6148   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6149   return jresult;
6150 }
6151
6152
6153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6154   void * jresult ;
6155   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6156   float arg2 ;
6157   Dali::Vector3 result;
6158
6159   arg1 = (Dali::Vector3 *)jarg1;
6160   arg2 = (float)jarg2;
6161   {
6162     try {
6163       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6164     } catch (std::out_of_range& e) {
6165       {
6166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6167       };
6168     } catch (std::exception& e) {
6169       {
6170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (Dali::DaliException e) {
6173       {
6174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6175       };
6176     } catch (...) {
6177       {
6178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6179       };
6180     }
6181   }
6182
6183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6184   return jresult;
6185 }
6186
6187
6188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6189   void * jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   Dali::Vector3 *arg2 = 0 ;
6192   Dali::Vector3 *result = 0 ;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   arg2 = (Dali::Vector3 *)jarg2;
6196   if (!arg2) {
6197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6198     return 0;
6199   }
6200   {
6201     try {
6202       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6203     } catch (std::out_of_range& e) {
6204       {
6205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6206       };
6207     } catch (std::exception& e) {
6208       {
6209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6210       };
6211     } catch (Dali::DaliException e) {
6212       {
6213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6214       };
6215     } catch (...) {
6216       {
6217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6218       };
6219     }
6220   }
6221
6222   jresult = (void *)result;
6223   return jresult;
6224 }
6225
6226
6227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6228   void * jresult ;
6229   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6230   float arg2 ;
6231   Dali::Vector3 *result = 0 ;
6232
6233   arg1 = (Dali::Vector3 *)jarg1;
6234   arg2 = (float)jarg2;
6235   {
6236     try {
6237       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6238     } catch (std::out_of_range& e) {
6239       {
6240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6241       };
6242     } catch (std::exception& e) {
6243       {
6244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6245       };
6246     } catch (Dali::DaliException e) {
6247       {
6248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6249       };
6250     } catch (...) {
6251       {
6252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6253       };
6254     }
6255   }
6256
6257   jresult = (void *)result;
6258   return jresult;
6259 }
6260
6261
6262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6263   void * jresult ;
6264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6265   Dali::Quaternion *arg2 = 0 ;
6266   Dali::Vector3 *result = 0 ;
6267
6268   arg1 = (Dali::Vector3 *)jarg1;
6269   arg2 = (Dali::Quaternion *)jarg2;
6270   if (!arg2) {
6271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6272     return 0;
6273   }
6274   {
6275     try {
6276       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6277     } catch (std::out_of_range& e) {
6278       {
6279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6280       };
6281     } catch (std::exception& e) {
6282       {
6283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6284       };
6285     } catch (Dali::DaliException e) {
6286       {
6287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6288       };
6289     } catch (...) {
6290       {
6291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6292       };
6293     }
6294   }
6295
6296   jresult = (void *)result;
6297   return jresult;
6298 }
6299
6300
6301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6302   void * jresult ;
6303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6304   Dali::Vector3 *arg2 = 0 ;
6305   Dali::Vector3 result;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   arg2 = (Dali::Vector3 *)jarg2;
6309   if (!arg2) {
6310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6311     return 0;
6312   }
6313   {
6314     try {
6315       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6316     } catch (std::out_of_range& e) {
6317       {
6318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6319       };
6320     } catch (std::exception& e) {
6321       {
6322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6323       };
6324     } catch (Dali::DaliException e) {
6325       {
6326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6327       };
6328     } catch (...) {
6329       {
6330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6331       };
6332     }
6333   }
6334
6335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6336   return jresult;
6337 }
6338
6339
6340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6341   void * jresult ;
6342   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6343   float arg2 ;
6344   Dali::Vector3 result;
6345
6346   arg1 = (Dali::Vector3 *)jarg1;
6347   arg2 = (float)jarg2;
6348   {
6349     try {
6350       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6351     } catch (std::out_of_range& e) {
6352       {
6353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6354       };
6355     } catch (std::exception& e) {
6356       {
6357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6358       };
6359     } catch (Dali::DaliException e) {
6360       {
6361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6362       };
6363     } catch (...) {
6364       {
6365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6366       };
6367     }
6368   }
6369
6370   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6371   return jresult;
6372 }
6373
6374
6375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6376   void * jresult ;
6377   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6378   Dali::Vector3 *arg2 = 0 ;
6379   Dali::Vector3 *result = 0 ;
6380
6381   arg1 = (Dali::Vector3 *)jarg1;
6382   arg2 = (Dali::Vector3 *)jarg2;
6383   if (!arg2) {
6384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6385     return 0;
6386   }
6387   {
6388     try {
6389       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6390     } catch (std::out_of_range& e) {
6391       {
6392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6393       };
6394     } catch (std::exception& e) {
6395       {
6396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6397       };
6398     } catch (Dali::DaliException e) {
6399       {
6400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6401       };
6402     } catch (...) {
6403       {
6404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6405       };
6406     }
6407   }
6408
6409   jresult = (void *)result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6415   void * jresult ;
6416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6417   float arg2 ;
6418   Dali::Vector3 *result = 0 ;
6419
6420   arg1 = (Dali::Vector3 *)jarg1;
6421   arg2 = (float)jarg2;
6422   {
6423     try {
6424       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6425     } catch (std::out_of_range& e) {
6426       {
6427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6428       };
6429     } catch (std::exception& e) {
6430       {
6431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6432       };
6433     } catch (Dali::DaliException e) {
6434       {
6435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6436       };
6437     } catch (...) {
6438       {
6439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6440       };
6441     }
6442   }
6443
6444   jresult = (void *)result;
6445   return jresult;
6446 }
6447
6448
6449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6450   void * jresult ;
6451   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6452   Dali::Vector3 result;
6453
6454   arg1 = (Dali::Vector3 *)jarg1;
6455   {
6456     try {
6457       result = ((Dali::Vector3 const *)arg1)->operator -();
6458     } catch (std::out_of_range& e) {
6459       {
6460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6461       };
6462     } catch (std::exception& e) {
6463       {
6464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6465       };
6466     } catch (Dali::DaliException e) {
6467       {
6468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6469       };
6470     } catch (...) {
6471       {
6472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6473       };
6474     }
6475   }
6476
6477   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6478   return jresult;
6479 }
6480
6481
6482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6483   unsigned int jresult ;
6484   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6485   Dali::Vector3 *arg2 = 0 ;
6486   bool result;
6487
6488   arg1 = (Dali::Vector3 *)jarg1;
6489   arg2 = (Dali::Vector3 *)jarg2;
6490   if (!arg2) {
6491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6492     return 0;
6493   }
6494   {
6495     try {
6496       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6497     } catch (std::out_of_range& e) {
6498       {
6499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6500       };
6501     } catch (std::exception& e) {
6502       {
6503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6504       };
6505     } catch (Dali::DaliException e) {
6506       {
6507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6508       };
6509     } catch (...) {
6510       {
6511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6512       };
6513     }
6514   }
6515
6516   jresult = result;
6517   return jresult;
6518 }
6519
6520
6521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6522   unsigned int jresult ;
6523   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6524   Dali::Vector3 *arg2 = 0 ;
6525   bool result;
6526
6527   arg1 = (Dali::Vector3 *)jarg1;
6528   arg2 = (Dali::Vector3 *)jarg2;
6529   if (!arg2) {
6530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6531     return 0;
6532   }
6533   {
6534     try {
6535       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6536     } catch (std::out_of_range& e) {
6537       {
6538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6539       };
6540     } catch (std::exception& e) {
6541       {
6542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6543       };
6544     } catch (Dali::DaliException e) {
6545       {
6546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6547       };
6548     } catch (...) {
6549       {
6550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6551       };
6552     }
6553   }
6554
6555   jresult = result;
6556   return jresult;
6557 }
6558
6559
6560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6561   float jresult ;
6562   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6563   unsigned int arg2 ;
6564   float *result = 0 ;
6565
6566   arg1 = (Dali::Vector3 *)jarg1;
6567   arg2 = (unsigned int)jarg2;
6568   {
6569     try {
6570       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6571     } catch (std::out_of_range& e) {
6572       {
6573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6574       };
6575     } catch (std::exception& e) {
6576       {
6577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6578       };
6579     } catch (Dali::DaliException e) {
6580       {
6581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6582       };
6583     } catch (...) {
6584       {
6585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6586       };
6587     }
6588   }
6589
6590   jresult = *result;
6591   return jresult;
6592 }
6593
6594
6595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6596   float jresult ;
6597   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6598   Dali::Vector3 *arg2 = 0 ;
6599   float result;
6600
6601   arg1 = (Dali::Vector3 *)jarg1;
6602   arg2 = (Dali::Vector3 *)jarg2;
6603   if (!arg2) {
6604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6605     return 0;
6606   }
6607   {
6608     try {
6609       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6610     } catch (std::out_of_range& e) {
6611       {
6612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6613       };
6614     } catch (std::exception& e) {
6615       {
6616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6617       };
6618     } catch (Dali::DaliException e) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6621       };
6622     } catch (...) {
6623       {
6624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6625       };
6626     }
6627   }
6628
6629   jresult = result;
6630   return jresult;
6631 }
6632
6633
6634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6635   void * jresult ;
6636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6637   Dali::Vector3 *arg2 = 0 ;
6638   Dali::Vector3 result;
6639
6640   arg1 = (Dali::Vector3 *)jarg1;
6641   arg2 = (Dali::Vector3 *)jarg2;
6642   if (!arg2) {
6643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6644     return 0;
6645   }
6646   {
6647     try {
6648       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6649     } catch (std::out_of_range& e) {
6650       {
6651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6652       };
6653     } catch (std::exception& e) {
6654       {
6655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6656       };
6657     } catch (Dali::DaliException e) {
6658       {
6659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6660       };
6661     } catch (...) {
6662       {
6663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6664       };
6665     }
6666   }
6667
6668   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6669   return jresult;
6670 }
6671
6672
6673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6674   float jresult ;
6675   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6676   float result;
6677
6678   arg1 = (Dali::Vector3 *)jarg1;
6679   {
6680     try {
6681       result = (float)((Dali::Vector3 const *)arg1)->Length();
6682     } catch (std::out_of_range& e) {
6683       {
6684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6685       };
6686     } catch (std::exception& e) {
6687       {
6688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6689       };
6690     } catch (Dali::DaliException e) {
6691       {
6692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6693       };
6694     } catch (...) {
6695       {
6696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6697       };
6698     }
6699   }
6700
6701   jresult = result;
6702   return jresult;
6703 }
6704
6705
6706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6707   float jresult ;
6708   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6709   float result;
6710
6711   arg1 = (Dali::Vector3 *)jarg1;
6712   {
6713     try {
6714       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6715     } catch (std::out_of_range& e) {
6716       {
6717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6718       };
6719     } catch (std::exception& e) {
6720       {
6721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6722       };
6723     } catch (Dali::DaliException e) {
6724       {
6725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6726       };
6727     } catch (...) {
6728       {
6729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6730       };
6731     }
6732   }
6733
6734   jresult = result;
6735   return jresult;
6736 }
6737
6738
6739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6740   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6741
6742   arg1 = (Dali::Vector3 *)jarg1;
6743   {
6744     try {
6745       (arg1)->Normalize();
6746     } catch (std::out_of_range& e) {
6747       {
6748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6749       };
6750     } catch (std::exception& e) {
6751       {
6752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6753       };
6754     } catch (Dali::DaliException e) {
6755       {
6756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6757       };
6758     } catch (...) {
6759       {
6760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6761       };
6762     }
6763   }
6764
6765 }
6766
6767
6768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6769   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6770   Dali::Vector3 *arg2 = 0 ;
6771   Dali::Vector3 *arg3 = 0 ;
6772
6773   arg1 = (Dali::Vector3 *)jarg1;
6774   arg2 = (Dali::Vector3 *)jarg2;
6775   if (!arg2) {
6776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6777     return ;
6778   }
6779   arg3 = (Dali::Vector3 *)jarg3;
6780   if (!arg3) {
6781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6782     return ;
6783   }
6784   {
6785     try {
6786       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6787     } catch (std::out_of_range& e) {
6788       {
6789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6790       };
6791     } catch (std::exception& e) {
6792       {
6793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6794       };
6795     } catch (Dali::DaliException e) {
6796       {
6797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6798       };
6799     } catch (...) {
6800       {
6801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6802       };
6803     }
6804   }
6805
6806 }
6807
6808
6809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6810   void * jresult ;
6811   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6812   float *result = 0 ;
6813
6814   arg1 = (Dali::Vector3 *)jarg1;
6815   {
6816     try {
6817       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6818     } catch (std::out_of_range& e) {
6819       {
6820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6821       };
6822     } catch (std::exception& e) {
6823       {
6824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6825       };
6826     } catch (Dali::DaliException e) {
6827       {
6828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6829       };
6830     } catch (...) {
6831       {
6832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6833       };
6834     }
6835   }
6836
6837   jresult = (void *)result;
6838   return jresult;
6839 }
6840
6841
6842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6843   void * jresult ;
6844   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6845   Dali::Vector2 *result = 0 ;
6846
6847   arg1 = (Dali::Vector3 *)jarg1;
6848   {
6849     try {
6850       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6851     } catch (std::out_of_range& e) {
6852       {
6853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6854       };
6855     } catch (std::exception& e) {
6856       {
6857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6858       };
6859     } catch (Dali::DaliException e) {
6860       {
6861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6862       };
6863     } catch (...) {
6864       {
6865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6866       };
6867     }
6868   }
6869
6870   jresult = (void *)result;
6871   return jresult;
6872 }
6873
6874
6875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6876   void * jresult ;
6877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6878   Dali::Vector2 *result = 0 ;
6879
6880   arg1 = (Dali::Vector3 *)jarg1;
6881   {
6882     try {
6883       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6884     } catch (std::out_of_range& e) {
6885       {
6886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6887       };
6888     } catch (std::exception& e) {
6889       {
6890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6891       };
6892     } catch (Dali::DaliException e) {
6893       {
6894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6895       };
6896     } catch (...) {
6897       {
6898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6899       };
6900     }
6901   }
6902
6903   jresult = (void *)result;
6904   return jresult;
6905 }
6906
6907
6908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6910   float arg2 ;
6911
6912   arg1 = (Dali::Vector3 *)jarg1;
6913   arg2 = (float)jarg2;
6914   if (arg1) (arg1)->x = arg2;
6915 }
6916
6917
6918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6919   float jresult ;
6920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6921   float result;
6922
6923   arg1 = (Dali::Vector3 *)jarg1;
6924   result = (float) ((arg1)->x);
6925   jresult = result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6931   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6932   float arg2 ;
6933
6934   arg1 = (Dali::Vector3 *)jarg1;
6935   arg2 = (float)jarg2;
6936   if (arg1) (arg1)->width = arg2;
6937 }
6938
6939
6940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6941   float jresult ;
6942   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6943   float result;
6944
6945   arg1 = (Dali::Vector3 *)jarg1;
6946   result = (float) ((arg1)->width);
6947   jresult = result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6954   float arg2 ;
6955
6956   arg1 = (Dali::Vector3 *)jarg1;
6957   arg2 = (float)jarg2;
6958   if (arg1) (arg1)->r = arg2;
6959 }
6960
6961
6962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6963   float jresult ;
6964   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6965   float result;
6966
6967   arg1 = (Dali::Vector3 *)jarg1;
6968   result = (float) ((arg1)->r);
6969   jresult = result;
6970   return jresult;
6971 }
6972
6973
6974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6975   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6976   float arg2 ;
6977
6978   arg1 = (Dali::Vector3 *)jarg1;
6979   arg2 = (float)jarg2;
6980   if (arg1) (arg1)->y = arg2;
6981 }
6982
6983
6984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6985   float jresult ;
6986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6987   float result;
6988
6989   arg1 = (Dali::Vector3 *)jarg1;
6990   result = (float) ((arg1)->y);
6991   jresult = result;
6992   return jresult;
6993 }
6994
6995
6996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6998   float arg2 ;
6999
7000   arg1 = (Dali::Vector3 *)jarg1;
7001   arg2 = (float)jarg2;
7002   if (arg1) (arg1)->height = arg2;
7003 }
7004
7005
7006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7007   float jresult ;
7008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7009   float result;
7010
7011   arg1 = (Dali::Vector3 *)jarg1;
7012   result = (float) ((arg1)->height);
7013   jresult = result;
7014   return jresult;
7015 }
7016
7017
7018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7020   float arg2 ;
7021
7022   arg1 = (Dali::Vector3 *)jarg1;
7023   arg2 = (float)jarg2;
7024   if (arg1) (arg1)->g = arg2;
7025 }
7026
7027
7028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7029   float jresult ;
7030   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7031   float result;
7032
7033   arg1 = (Dali::Vector3 *)jarg1;
7034   result = (float) ((arg1)->g);
7035   jresult = result;
7036   return jresult;
7037 }
7038
7039
7040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7042   float arg2 ;
7043
7044   arg1 = (Dali::Vector3 *)jarg1;
7045   arg2 = (float)jarg2;
7046   if (arg1) (arg1)->z = arg2;
7047 }
7048
7049
7050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7051   float jresult ;
7052   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7053   float result;
7054
7055   arg1 = (Dali::Vector3 *)jarg1;
7056   result = (float) ((arg1)->z);
7057   jresult = result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7063   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7064   float arg2 ;
7065
7066   arg1 = (Dali::Vector3 *)jarg1;
7067   arg2 = (float)jarg2;
7068   if (arg1) (arg1)->depth = arg2;
7069 }
7070
7071
7072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7073   float jresult ;
7074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7075   float result;
7076
7077   arg1 = (Dali::Vector3 *)jarg1;
7078   result = (float) ((arg1)->depth);
7079   jresult = result;
7080   return jresult;
7081 }
7082
7083
7084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7086   float arg2 ;
7087
7088   arg1 = (Dali::Vector3 *)jarg1;
7089   arg2 = (float)jarg2;
7090   if (arg1) (arg1)->b = arg2;
7091 }
7092
7093
7094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7095   float jresult ;
7096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7097   float result;
7098
7099   arg1 = (Dali::Vector3 *)jarg1;
7100   result = (float) ((arg1)->b);
7101   jresult = result;
7102   return jresult;
7103 }
7104
7105
7106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7107   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7108
7109   arg1 = (Dali::Vector3 *)jarg1;
7110   {
7111     try {
7112       delete arg1;
7113     } catch (std::out_of_range& e) {
7114       {
7115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7116       };
7117     } catch (std::exception& e) {
7118       {
7119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7120       };
7121     } catch (Dali::DaliException e) {
7122       {
7123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7124       };
7125     } catch (...) {
7126       {
7127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7128       };
7129     }
7130   }
7131
7132 }
7133
7134
7135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7136   void * jresult ;
7137   Dali::Vector3 *arg1 = 0 ;
7138   Dali::Vector3 *arg2 = 0 ;
7139   Dali::Vector3 result;
7140
7141   arg1 = (Dali::Vector3 *)jarg1;
7142   if (!arg1) {
7143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7144     return 0;
7145   }
7146   arg2 = (Dali::Vector3 *)jarg2;
7147   if (!arg2) {
7148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7149     return 0;
7150   }
7151   {
7152     try {
7153       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7154     } catch (std::out_of_range& e) {
7155       {
7156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7157       };
7158     } catch (std::exception& e) {
7159       {
7160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7161       };
7162     } catch (Dali::DaliException e) {
7163       {
7164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7165       };
7166     } catch (...) {
7167       {
7168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7169       };
7170     }
7171   }
7172
7173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7174   return jresult;
7175 }
7176
7177
7178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7179   void * jresult ;
7180   Dali::Vector3 *arg1 = 0 ;
7181   Dali::Vector3 *arg2 = 0 ;
7182   Dali::Vector3 result;
7183
7184   arg1 = (Dali::Vector3 *)jarg1;
7185   if (!arg1) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   arg2 = (Dali::Vector3 *)jarg2;
7190   if (!arg2) {
7191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7192     return 0;
7193   }
7194   {
7195     try {
7196       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7197     } catch (std::out_of_range& e) {
7198       {
7199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7200       };
7201     } catch (std::exception& e) {
7202       {
7203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (Dali::DaliException e) {
7206       {
7207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215
7216   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7217   return jresult;
7218 }
7219
7220
7221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7222   void * jresult ;
7223   Dali::Vector3 *arg1 = 0 ;
7224   float *arg2 = 0 ;
7225   float *arg3 = 0 ;
7226   float temp2 ;
7227   float temp3 ;
7228   Dali::Vector3 result;
7229
7230   arg1 = (Dali::Vector3 *)jarg1;
7231   if (!arg1) {
7232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7233     return 0;
7234   }
7235   temp2 = (float)jarg2;
7236   arg2 = &temp2;
7237   temp3 = (float)jarg3;
7238   arg3 = &temp3;
7239   {
7240     try {
7241       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7242     } catch (std::out_of_range& e) {
7243       {
7244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7245       };
7246     } catch (std::exception& e) {
7247       {
7248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7249       };
7250     } catch (Dali::DaliException e) {
7251       {
7252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7253       };
7254     } catch (...) {
7255       {
7256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7257       };
7258     }
7259   }
7260
7261   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7262   return jresult;
7263 }
7264
7265
7266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7267   void * jresult ;
7268   Dali::Vector4 *result = 0 ;
7269
7270   {
7271     try {
7272       result = (Dali::Vector4 *)new Dali::Vector4();
7273     } catch (std::out_of_range& e) {
7274       {
7275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7276       };
7277     } catch (std::exception& e) {
7278       {
7279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7280       };
7281     } catch (Dali::DaliException e) {
7282       {
7283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7284       };
7285     } catch (...) {
7286       {
7287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7288       };
7289     }
7290   }
7291
7292   jresult = (void *)result;
7293   return jresult;
7294 }
7295
7296
7297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7298   void * jresult ;
7299   float arg1 ;
7300   float arg2 ;
7301   float arg3 ;
7302   float arg4 ;
7303   Dali::Vector4 *result = 0 ;
7304
7305   arg1 = (float)jarg1;
7306   arg2 = (float)jarg2;
7307   arg3 = (float)jarg3;
7308   arg4 = (float)jarg4;
7309   {
7310     try {
7311       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7312     } catch (std::out_of_range& e) {
7313       {
7314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7315       };
7316     } catch (std::exception& e) {
7317       {
7318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (Dali::DaliException e) {
7321       {
7322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7323       };
7324     } catch (...) {
7325       {
7326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7327       };
7328     }
7329   }
7330
7331   jresult = (void *)result;
7332   return jresult;
7333 }
7334
7335
7336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7337   void * jresult ;
7338   float *arg1 = (float *) 0 ;
7339   Dali::Vector4 *result = 0 ;
7340
7341   arg1 = jarg1;
7342   {
7343     try {
7344       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7345     } catch (std::out_of_range& e) {
7346       {
7347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7348       };
7349     } catch (std::exception& e) {
7350       {
7351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7352       };
7353     } catch (Dali::DaliException e) {
7354       {
7355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7356       };
7357     } catch (...) {
7358       {
7359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7360       };
7361     }
7362   }
7363
7364   jresult = (void *)result;
7365
7366
7367   return jresult;
7368 }
7369
7370
7371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7372   void * jresult ;
7373   Dali::Vector2 *arg1 = 0 ;
7374   Dali::Vector4 *result = 0 ;
7375
7376   arg1 = (Dali::Vector2 *)jarg1;
7377   if (!arg1) {
7378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7379     return 0;
7380   }
7381   {
7382     try {
7383       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7384     } catch (std::out_of_range& e) {
7385       {
7386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (std::exception& e) {
7389       {
7390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7391       };
7392     } catch (Dali::DaliException e) {
7393       {
7394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7395       };
7396     } catch (...) {
7397       {
7398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7399       };
7400     }
7401   }
7402
7403   jresult = (void *)result;
7404   return jresult;
7405 }
7406
7407
7408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7409   void * jresult ;
7410   Dali::Vector3 *arg1 = 0 ;
7411   Dali::Vector4 *result = 0 ;
7412
7413   arg1 = (Dali::Vector3 *)jarg1;
7414   if (!arg1) {
7415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7416     return 0;
7417   }
7418   {
7419     try {
7420       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7421     } catch (std::out_of_range& e) {
7422       {
7423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7424       };
7425     } catch (std::exception& e) {
7426       {
7427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7428       };
7429     } catch (Dali::DaliException e) {
7430       {
7431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7432       };
7433     } catch (...) {
7434       {
7435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7436       };
7437     }
7438   }
7439
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7466   void * jresult ;
7467   Dali::Vector4 *result = 0 ;
7468
7469   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7470   jresult = (void *)result;
7471   return jresult;
7472 }
7473
7474
7475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7476   void * jresult ;
7477   Dali::Vector4 *result = 0 ;
7478
7479   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7480   jresult = (void *)result;
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7486   void * jresult ;
7487   Dali::Vector4 *result = 0 ;
7488
7489   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7490   jresult = (void *)result;
7491   return jresult;
7492 }
7493
7494
7495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7496   void * jresult ;
7497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7498   float *arg2 = (float *) 0 ;
7499   Dali::Vector4 *result = 0 ;
7500
7501   arg1 = (Dali::Vector4 *)jarg1;
7502   arg2 = jarg2;
7503   {
7504     try {
7505       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7506     } catch (std::out_of_range& e) {
7507       {
7508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7509       };
7510     } catch (std::exception& e) {
7511       {
7512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7513       };
7514     } catch (Dali::DaliException e) {
7515       {
7516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7517       };
7518     } catch (...) {
7519       {
7520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7521       };
7522     }
7523   }
7524
7525   jresult = (void *)result;
7526
7527
7528   return jresult;
7529 }
7530
7531
7532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7533   void * jresult ;
7534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7535   Dali::Vector2 *arg2 = 0 ;
7536   Dali::Vector4 *result = 0 ;
7537
7538   arg1 = (Dali::Vector4 *)jarg1;
7539   arg2 = (Dali::Vector2 *)jarg2;
7540   if (!arg2) {
7541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7542     return 0;
7543   }
7544   {
7545     try {
7546       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7547     } catch (std::out_of_range& e) {
7548       {
7549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7550       };
7551     } catch (std::exception& e) {
7552       {
7553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7554       };
7555     } catch (Dali::DaliException e) {
7556       {
7557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7558       };
7559     } catch (...) {
7560       {
7561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7562       };
7563     }
7564   }
7565
7566   jresult = (void *)result;
7567   return jresult;
7568 }
7569
7570
7571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7572   void * jresult ;
7573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7574   Dali::Vector3 *arg2 = 0 ;
7575   Dali::Vector4 *result = 0 ;
7576
7577   arg1 = (Dali::Vector4 *)jarg1;
7578   arg2 = (Dali::Vector3 *)jarg2;
7579   if (!arg2) {
7580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7581     return 0;
7582   }
7583   {
7584     try {
7585       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7586     } catch (std::out_of_range& e) {
7587       {
7588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7589       };
7590     } catch (std::exception& e) {
7591       {
7592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7593       };
7594     } catch (Dali::DaliException e) {
7595       {
7596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7597       };
7598     } catch (...) {
7599       {
7600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7601       };
7602     }
7603   }
7604
7605   jresult = (void *)result;
7606   return jresult;
7607 }
7608
7609
7610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7611   void * jresult ;
7612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7613   Dali::Vector4 *arg2 = 0 ;
7614   Dali::Vector4 result;
7615
7616   arg1 = (Dali::Vector4 *)jarg1;
7617   arg2 = (Dali::Vector4 *)jarg2;
7618   if (!arg2) {
7619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7620     return 0;
7621   }
7622   {
7623     try {
7624       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7625     } catch (std::out_of_range& e) {
7626       {
7627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7628       };
7629     } catch (std::exception& e) {
7630       {
7631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7632       };
7633     } catch (Dali::DaliException e) {
7634       {
7635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7636       };
7637     } catch (...) {
7638       {
7639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7640       };
7641     }
7642   }
7643
7644   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7645   return jresult;
7646 }
7647
7648
7649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7650   void * jresult ;
7651   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7652   Dali::Vector4 *arg2 = 0 ;
7653   Dali::Vector4 *result = 0 ;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   arg2 = (Dali::Vector4 *)jarg2;
7657   if (!arg2) {
7658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7659     return 0;
7660   }
7661   {
7662     try {
7663       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7664     } catch (std::out_of_range& e) {
7665       {
7666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7667       };
7668     } catch (std::exception& e) {
7669       {
7670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7671       };
7672     } catch (Dali::DaliException e) {
7673       {
7674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7675       };
7676     } catch (...) {
7677       {
7678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7679       };
7680     }
7681   }
7682
7683   jresult = (void *)result;
7684   return jresult;
7685 }
7686
7687
7688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7689   void * jresult ;
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   Dali::Vector4 *arg2 = 0 ;
7692   Dali::Vector4 result;
7693
7694   arg1 = (Dali::Vector4 *)jarg1;
7695   arg2 = (Dali::Vector4 *)jarg2;
7696   if (!arg2) {
7697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7698     return 0;
7699   }
7700   {
7701     try {
7702       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7703     } catch (std::out_of_range& e) {
7704       {
7705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7706       };
7707     } catch (std::exception& e) {
7708       {
7709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7710       };
7711     } catch (Dali::DaliException e) {
7712       {
7713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7714       };
7715     } catch (...) {
7716       {
7717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7718       };
7719     }
7720   }
7721
7722   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7723   return jresult;
7724 }
7725
7726
7727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7728   void * jresult ;
7729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7730   Dali::Vector4 *arg2 = 0 ;
7731   Dali::Vector4 *result = 0 ;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   arg2 = (Dali::Vector4 *)jarg2;
7735   if (!arg2) {
7736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7737     return 0;
7738   }
7739   {
7740     try {
7741       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7742     } catch (std::out_of_range& e) {
7743       {
7744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7745       };
7746     } catch (std::exception& e) {
7747       {
7748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7749       };
7750     } catch (Dali::DaliException e) {
7751       {
7752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7753       };
7754     } catch (...) {
7755       {
7756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7757       };
7758     }
7759   }
7760
7761   jresult = (void *)result;
7762   return jresult;
7763 }
7764
7765
7766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7767   void * jresult ;
7768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7769   Dali::Vector4 *arg2 = 0 ;
7770   Dali::Vector4 result;
7771
7772   arg1 = (Dali::Vector4 *)jarg1;
7773   arg2 = (Dali::Vector4 *)jarg2;
7774   if (!arg2) {
7775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7776     return 0;
7777   }
7778   {
7779     try {
7780       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7781     } catch (std::out_of_range& e) {
7782       {
7783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7784       };
7785     } catch (std::exception& e) {
7786       {
7787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7788       };
7789     } catch (Dali::DaliException e) {
7790       {
7791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7792       };
7793     } catch (...) {
7794       {
7795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7796       };
7797     }
7798   }
7799
7800   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7801   return jresult;
7802 }
7803
7804
7805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7806   void * jresult ;
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float arg2 ;
7809   Dali::Vector4 result;
7810
7811   arg1 = (Dali::Vector4 *)jarg1;
7812   arg2 = (float)jarg2;
7813   {
7814     try {
7815       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7816     } catch (std::out_of_range& e) {
7817       {
7818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7819       };
7820     } catch (std::exception& e) {
7821       {
7822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7823       };
7824     } catch (Dali::DaliException e) {
7825       {
7826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7827       };
7828     } catch (...) {
7829       {
7830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7831       };
7832     }
7833   }
7834
7835   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7836   return jresult;
7837 }
7838
7839
7840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7841   void * jresult ;
7842   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7843   Dali::Vector4 *arg2 = 0 ;
7844   Dali::Vector4 *result = 0 ;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   arg2 = (Dali::Vector4 *)jarg2;
7848   if (!arg2) {
7849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7850     return 0;
7851   }
7852   {
7853     try {
7854       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7855     } catch (std::out_of_range& e) {
7856       {
7857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7858       };
7859     } catch (std::exception& e) {
7860       {
7861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7862       };
7863     } catch (Dali::DaliException e) {
7864       {
7865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7866       };
7867     } catch (...) {
7868       {
7869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7870       };
7871     }
7872   }
7873
7874   jresult = (void *)result;
7875   return jresult;
7876 }
7877
7878
7879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7880   void * jresult ;
7881   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7882   float arg2 ;
7883   Dali::Vector4 *result = 0 ;
7884
7885   arg1 = (Dali::Vector4 *)jarg1;
7886   arg2 = (float)jarg2;
7887   {
7888     try {
7889       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7890     } catch (std::out_of_range& e) {
7891       {
7892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7893       };
7894     } catch (std::exception& e) {
7895       {
7896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7897       };
7898     } catch (Dali::DaliException e) {
7899       {
7900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7901       };
7902     } catch (...) {
7903       {
7904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7905       };
7906     }
7907   }
7908
7909   jresult = (void *)result;
7910   return jresult;
7911 }
7912
7913
7914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7915   void * jresult ;
7916   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7917   Dali::Vector4 *arg2 = 0 ;
7918   Dali::Vector4 result;
7919
7920   arg1 = (Dali::Vector4 *)jarg1;
7921   arg2 = (Dali::Vector4 *)jarg2;
7922   if (!arg2) {
7923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7924     return 0;
7925   }
7926   {
7927     try {
7928       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7929     } catch (std::out_of_range& e) {
7930       {
7931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7932       };
7933     } catch (std::exception& e) {
7934       {
7935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7936       };
7937     } catch (Dali::DaliException e) {
7938       {
7939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7940       };
7941     } catch (...) {
7942       {
7943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7944       };
7945     }
7946   }
7947
7948   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7949   return jresult;
7950 }
7951
7952
7953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7954   void * jresult ;
7955   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7956   float arg2 ;
7957   Dali::Vector4 result;
7958
7959   arg1 = (Dali::Vector4 *)jarg1;
7960   arg2 = (float)jarg2;
7961   {
7962     try {
7963       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7964     } catch (std::out_of_range& e) {
7965       {
7966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7967       };
7968     } catch (std::exception& e) {
7969       {
7970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7971       };
7972     } catch (Dali::DaliException e) {
7973       {
7974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7975       };
7976     } catch (...) {
7977       {
7978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7979       };
7980     }
7981   }
7982
7983   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7984   return jresult;
7985 }
7986
7987
7988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7989   void * jresult ;
7990   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7991   Dali::Vector4 *arg2 = 0 ;
7992   Dali::Vector4 *result = 0 ;
7993
7994   arg1 = (Dali::Vector4 *)jarg1;
7995   arg2 = (Dali::Vector4 *)jarg2;
7996   if (!arg2) {
7997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7998     return 0;
7999   }
8000   {
8001     try {
8002       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8003     } catch (std::out_of_range& e) {
8004       {
8005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8006       };
8007     } catch (std::exception& e) {
8008       {
8009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8010       };
8011     } catch (Dali::DaliException e) {
8012       {
8013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8014       };
8015     } catch (...) {
8016       {
8017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8018       };
8019     }
8020   }
8021
8022   jresult = (void *)result;
8023   return jresult;
8024 }
8025
8026
8027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8028   void * jresult ;
8029   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8030   float arg2 ;
8031   Dali::Vector4 *result = 0 ;
8032
8033   arg1 = (Dali::Vector4 *)jarg1;
8034   arg2 = (float)jarg2;
8035   {
8036     try {
8037       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8038     } catch (std::out_of_range& e) {
8039       {
8040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8041       };
8042     } catch (std::exception& e) {
8043       {
8044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8045       };
8046     } catch (Dali::DaliException e) {
8047       {
8048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8049       };
8050     } catch (...) {
8051       {
8052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8053       };
8054     }
8055   }
8056
8057   jresult = (void *)result;
8058   return jresult;
8059 }
8060
8061
8062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8063   void * jresult ;
8064   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8065   Dali::Vector4 result;
8066
8067   arg1 = (Dali::Vector4 *)jarg1;
8068   {
8069     try {
8070       result = ((Dali::Vector4 const *)arg1)->operator -();
8071     } catch (std::out_of_range& e) {
8072       {
8073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8074       };
8075     } catch (std::exception& e) {
8076       {
8077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8078       };
8079     } catch (Dali::DaliException e) {
8080       {
8081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8082       };
8083     } catch (...) {
8084       {
8085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8086       };
8087     }
8088   }
8089
8090   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8091   return jresult;
8092 }
8093
8094
8095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8096   unsigned int jresult ;
8097   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8098   Dali::Vector4 *arg2 = 0 ;
8099   bool result;
8100
8101   arg1 = (Dali::Vector4 *)jarg1;
8102   arg2 = (Dali::Vector4 *)jarg2;
8103   if (!arg2) {
8104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8105     return 0;
8106   }
8107   {
8108     try {
8109       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8110     } catch (std::out_of_range& e) {
8111       {
8112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8113       };
8114     } catch (std::exception& e) {
8115       {
8116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8117       };
8118     } catch (Dali::DaliException e) {
8119       {
8120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8121       };
8122     } catch (...) {
8123       {
8124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8125       };
8126     }
8127   }
8128
8129   jresult = result;
8130   return jresult;
8131 }
8132
8133
8134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8135   unsigned int jresult ;
8136   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8137   Dali::Vector4 *arg2 = 0 ;
8138   bool result;
8139
8140   arg1 = (Dali::Vector4 *)jarg1;
8141   arg2 = (Dali::Vector4 *)jarg2;
8142   if (!arg2) {
8143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8144     return 0;
8145   }
8146   {
8147     try {
8148       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8149     } catch (std::out_of_range& e) {
8150       {
8151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8152       };
8153     } catch (std::exception& e) {
8154       {
8155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8156       };
8157     } catch (Dali::DaliException e) {
8158       {
8159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8160       };
8161     } catch (...) {
8162       {
8163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8164       };
8165     }
8166   }
8167
8168   jresult = result;
8169   return jresult;
8170 }
8171
8172
8173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8174   float jresult ;
8175   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8176   unsigned int arg2 ;
8177   float *result = 0 ;
8178
8179   arg1 = (Dali::Vector4 *)jarg1;
8180   arg2 = (unsigned int)jarg2;
8181   {
8182     try {
8183       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8184     } catch (std::out_of_range& e) {
8185       {
8186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8187       };
8188     } catch (std::exception& e) {
8189       {
8190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8191       };
8192     } catch (Dali::DaliException e) {
8193       {
8194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8195       };
8196     } catch (...) {
8197       {
8198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8199       };
8200     }
8201   }
8202
8203   jresult = *result;
8204   return jresult;
8205 }
8206
8207
8208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8209   float jresult ;
8210   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8211   Dali::Vector3 *arg2 = 0 ;
8212   float result;
8213
8214   arg1 = (Dali::Vector4 *)jarg1;
8215   arg2 = (Dali::Vector3 *)jarg2;
8216   if (!arg2) {
8217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8218     return 0;
8219   }
8220   {
8221     try {
8222       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8223     } catch (std::out_of_range& e) {
8224       {
8225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8226       };
8227     } catch (std::exception& e) {
8228       {
8229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8230       };
8231     } catch (Dali::DaliException e) {
8232       {
8233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8234       };
8235     } catch (...) {
8236       {
8237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8238       };
8239     }
8240   }
8241
8242   jresult = result;
8243   return jresult;
8244 }
8245
8246
8247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8248   float jresult ;
8249   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8250   Dali::Vector4 *arg2 = 0 ;
8251   float result;
8252
8253   arg1 = (Dali::Vector4 *)jarg1;
8254   arg2 = (Dali::Vector4 *)jarg2;
8255   if (!arg2) {
8256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8257     return 0;
8258   }
8259   {
8260     try {
8261       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8262     } catch (std::out_of_range& e) {
8263       {
8264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8265       };
8266     } catch (std::exception& e) {
8267       {
8268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8269       };
8270     } catch (Dali::DaliException e) {
8271       {
8272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8273       };
8274     } catch (...) {
8275       {
8276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8277       };
8278     }
8279   }
8280
8281   jresult = result;
8282   return jresult;
8283 }
8284
8285
8286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8287   float jresult ;
8288   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8289   Dali::Vector4 *arg2 = 0 ;
8290   float result;
8291
8292   arg1 = (Dali::Vector4 *)jarg1;
8293   arg2 = (Dali::Vector4 *)jarg2;
8294   if (!arg2) {
8295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8296     return 0;
8297   }
8298   {
8299     try {
8300       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8301     } catch (std::out_of_range& e) {
8302       {
8303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8304       };
8305     } catch (std::exception& e) {
8306       {
8307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8308       };
8309     } catch (Dali::DaliException e) {
8310       {
8311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8312       };
8313     } catch (...) {
8314       {
8315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8316       };
8317     }
8318   }
8319
8320   jresult = result;
8321   return jresult;
8322 }
8323
8324
8325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8326   void * jresult ;
8327   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8328   Dali::Vector4 *arg2 = 0 ;
8329   Dali::Vector4 result;
8330
8331   arg1 = (Dali::Vector4 *)jarg1;
8332   arg2 = (Dali::Vector4 *)jarg2;
8333   if (!arg2) {
8334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8335     return 0;
8336   }
8337   {
8338     try {
8339       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8340     } catch (std::out_of_range& e) {
8341       {
8342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8343       };
8344     } catch (std::exception& e) {
8345       {
8346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8347       };
8348     } catch (Dali::DaliException e) {
8349       {
8350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8351       };
8352     } catch (...) {
8353       {
8354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8355       };
8356     }
8357   }
8358
8359   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8360   return jresult;
8361 }
8362
8363
8364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8365   float jresult ;
8366   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8367   float result;
8368
8369   arg1 = (Dali::Vector4 *)jarg1;
8370   {
8371     try {
8372       result = (float)((Dali::Vector4 const *)arg1)->Length();
8373     } catch (std::out_of_range& e) {
8374       {
8375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8376       };
8377     } catch (std::exception& e) {
8378       {
8379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8380       };
8381     } catch (Dali::DaliException e) {
8382       {
8383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8384       };
8385     } catch (...) {
8386       {
8387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8388       };
8389     }
8390   }
8391
8392   jresult = result;
8393   return jresult;
8394 }
8395
8396
8397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8398   float jresult ;
8399   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8400   float result;
8401
8402   arg1 = (Dali::Vector4 *)jarg1;
8403   {
8404     try {
8405       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8406     } catch (std::out_of_range& e) {
8407       {
8408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (std::exception& e) {
8411       {
8412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8413       };
8414     } catch (Dali::DaliException e) {
8415       {
8416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8417       };
8418     } catch (...) {
8419       {
8420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8421       };
8422     }
8423   }
8424
8425   jresult = result;
8426   return jresult;
8427 }
8428
8429
8430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8431   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8432
8433   arg1 = (Dali::Vector4 *)jarg1;
8434   {
8435     try {
8436       (arg1)->Normalize();
8437     } catch (std::out_of_range& e) {
8438       {
8439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8440       };
8441     } catch (std::exception& e) {
8442       {
8443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8444       };
8445     } catch (Dali::DaliException e) {
8446       {
8447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8448       };
8449     } catch (...) {
8450       {
8451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8452       };
8453     }
8454   }
8455
8456 }
8457
8458
8459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8460   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8461   Dali::Vector4 *arg2 = 0 ;
8462   Dali::Vector4 *arg3 = 0 ;
8463
8464   arg1 = (Dali::Vector4 *)jarg1;
8465   arg2 = (Dali::Vector4 *)jarg2;
8466   if (!arg2) {
8467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8468     return ;
8469   }
8470   arg3 = (Dali::Vector4 *)jarg3;
8471   if (!arg3) {
8472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8473     return ;
8474   }
8475   {
8476     try {
8477       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8478     } catch (std::out_of_range& e) {
8479       {
8480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8481       };
8482     } catch (std::exception& e) {
8483       {
8484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8485       };
8486     } catch (Dali::DaliException e) {
8487       {
8488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8489       };
8490     } catch (...) {
8491       {
8492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8493       };
8494     }
8495   }
8496
8497 }
8498
8499
8500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8501   void * jresult ;
8502   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8503   float *result = 0 ;
8504
8505   arg1 = (Dali::Vector4 *)jarg1;
8506   {
8507     try {
8508       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8509     } catch (std::out_of_range& e) {
8510       {
8511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8512       };
8513     } catch (std::exception& e) {
8514       {
8515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8516       };
8517     } catch (Dali::DaliException e) {
8518       {
8519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8520       };
8521     } catch (...) {
8522       {
8523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8524       };
8525     }
8526   }
8527
8528   jresult = (void *)result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8535   float arg2 ;
8536
8537   arg1 = (Dali::Vector4 *)jarg1;
8538   arg2 = (float)jarg2;
8539   if (arg1) (arg1)->x = arg2;
8540 }
8541
8542
8543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8544   float jresult ;
8545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8546   float result;
8547
8548   arg1 = (Dali::Vector4 *)jarg1;
8549   result = (float) ((arg1)->x);
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8556   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8557   float arg2 ;
8558
8559   arg1 = (Dali::Vector4 *)jarg1;
8560   arg2 = (float)jarg2;
8561   if (arg1) (arg1)->r = arg2;
8562 }
8563
8564
8565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8566   float jresult ;
8567   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8568   float result;
8569
8570   arg1 = (Dali::Vector4 *)jarg1;
8571   result = (float) ((arg1)->r);
8572   jresult = result;
8573   return jresult;
8574 }
8575
8576
8577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8579   float arg2 ;
8580
8581   arg1 = (Dali::Vector4 *)jarg1;
8582   arg2 = (float)jarg2;
8583   if (arg1) (arg1)->s = arg2;
8584 }
8585
8586
8587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8588   float jresult ;
8589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8590   float result;
8591
8592   arg1 = (Dali::Vector4 *)jarg1;
8593   result = (float) ((arg1)->s);
8594   jresult = result;
8595   return jresult;
8596 }
8597
8598
8599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8600   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8601   float arg2 ;
8602
8603   arg1 = (Dali::Vector4 *)jarg1;
8604   arg2 = (float)jarg2;
8605   if (arg1) (arg1)->y = arg2;
8606 }
8607
8608
8609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8610   float jresult ;
8611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8612   float result;
8613
8614   arg1 = (Dali::Vector4 *)jarg1;
8615   result = (float) ((arg1)->y);
8616   jresult = result;
8617   return jresult;
8618 }
8619
8620
8621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8622   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8623   float arg2 ;
8624
8625   arg1 = (Dali::Vector4 *)jarg1;
8626   arg2 = (float)jarg2;
8627   if (arg1) (arg1)->g = arg2;
8628 }
8629
8630
8631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8632   float jresult ;
8633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8634   float result;
8635
8636   arg1 = (Dali::Vector4 *)jarg1;
8637   result = (float) ((arg1)->g);
8638   jresult = result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8645   float arg2 ;
8646
8647   arg1 = (Dali::Vector4 *)jarg1;
8648   arg2 = (float)jarg2;
8649   if (arg1) (arg1)->t = arg2;
8650 }
8651
8652
8653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8654   float jresult ;
8655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8656   float result;
8657
8658   arg1 = (Dali::Vector4 *)jarg1;
8659   result = (float) ((arg1)->t);
8660   jresult = result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8666   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8667   float arg2 ;
8668
8669   arg1 = (Dali::Vector4 *)jarg1;
8670   arg2 = (float)jarg2;
8671   if (arg1) (arg1)->z = arg2;
8672 }
8673
8674
8675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8676   float jresult ;
8677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8678   float result;
8679
8680   arg1 = (Dali::Vector4 *)jarg1;
8681   result = (float) ((arg1)->z);
8682   jresult = result;
8683   return jresult;
8684 }
8685
8686
8687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8689   float arg2 ;
8690
8691   arg1 = (Dali::Vector4 *)jarg1;
8692   arg2 = (float)jarg2;
8693   if (arg1) (arg1)->b = arg2;
8694 }
8695
8696
8697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8698   float jresult ;
8699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8700   float result;
8701
8702   arg1 = (Dali::Vector4 *)jarg1;
8703   result = (float) ((arg1)->b);
8704   jresult = result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8711   float arg2 ;
8712
8713   arg1 = (Dali::Vector4 *)jarg1;
8714   arg2 = (float)jarg2;
8715   if (arg1) (arg1)->p = arg2;
8716 }
8717
8718
8719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8720   float jresult ;
8721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8722   float result;
8723
8724   arg1 = (Dali::Vector4 *)jarg1;
8725   result = (float) ((arg1)->p);
8726   jresult = result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8733   float arg2 ;
8734
8735   arg1 = (Dali::Vector4 *)jarg1;
8736   arg2 = (float)jarg2;
8737   if (arg1) (arg1)->w = arg2;
8738 }
8739
8740
8741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8742   float jresult ;
8743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8744   float result;
8745
8746   arg1 = (Dali::Vector4 *)jarg1;
8747   result = (float) ((arg1)->w);
8748   jresult = result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8755   float arg2 ;
8756
8757   arg1 = (Dali::Vector4 *)jarg1;
8758   arg2 = (float)jarg2;
8759   if (arg1) (arg1)->a = arg2;
8760 }
8761
8762
8763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8764   float jresult ;
8765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8766   float result;
8767
8768   arg1 = (Dali::Vector4 *)jarg1;
8769   result = (float) ((arg1)->a);
8770   jresult = result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8777   float arg2 ;
8778
8779   arg1 = (Dali::Vector4 *)jarg1;
8780   arg2 = (float)jarg2;
8781   if (arg1) (arg1)->q = arg2;
8782 }
8783
8784
8785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8786   float jresult ;
8787   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8788   float result;
8789
8790   arg1 = (Dali::Vector4 *)jarg1;
8791   result = (float) ((arg1)->q);
8792   jresult = result;
8793   return jresult;
8794 }
8795
8796
8797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8799
8800   arg1 = (Dali::Vector4 *)jarg1;
8801   {
8802     try {
8803       delete arg1;
8804     } catch (std::out_of_range& e) {
8805       {
8806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8807       };
8808     } catch (std::exception& e) {
8809       {
8810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8811       };
8812     } catch (Dali::DaliException e) {
8813       {
8814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8815       };
8816     } catch (...) {
8817       {
8818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8819       };
8820     }
8821   }
8822
8823 }
8824
8825
8826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8827   void * jresult ;
8828   Dali::Vector4 *arg1 = 0 ;
8829   Dali::Vector4 *arg2 = 0 ;
8830   Dali::Vector4 result;
8831
8832   arg1 = (Dali::Vector4 *)jarg1;
8833   if (!arg1) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8835     return 0;
8836   }
8837   arg2 = (Dali::Vector4 *)jarg2;
8838   if (!arg2) {
8839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8840     return 0;
8841   }
8842   {
8843     try {
8844       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8845     } catch (std::out_of_range& e) {
8846       {
8847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8848       };
8849     } catch (std::exception& e) {
8850       {
8851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8852       };
8853     } catch (Dali::DaliException e) {
8854       {
8855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8856       };
8857     } catch (...) {
8858       {
8859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8860       };
8861     }
8862   }
8863
8864   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8865   return jresult;
8866 }
8867
8868
8869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8870   void * jresult ;
8871   Dali::Vector4 *arg1 = 0 ;
8872   Dali::Vector4 *arg2 = 0 ;
8873   Dali::Vector4 result;
8874
8875   arg1 = (Dali::Vector4 *)jarg1;
8876   if (!arg1) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   arg2 = (Dali::Vector4 *)jarg2;
8881   if (!arg2) {
8882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8883     return 0;
8884   }
8885   {
8886     try {
8887       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8888     } catch (std::out_of_range& e) {
8889       {
8890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8891       };
8892     } catch (std::exception& e) {
8893       {
8894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (Dali::DaliException e) {
8897       {
8898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906
8907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8908   return jresult;
8909 }
8910
8911
8912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8913   void * jresult ;
8914   Dali::Vector4 *arg1 = 0 ;
8915   float *arg2 = 0 ;
8916   float *arg3 = 0 ;
8917   float temp2 ;
8918   float temp3 ;
8919   Dali::Vector4 result;
8920
8921   arg1 = (Dali::Vector4 *)jarg1;
8922   if (!arg1) {
8923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8924     return 0;
8925   }
8926   temp2 = (float)jarg2;
8927   arg2 = &temp2;
8928   temp3 = (float)jarg3;
8929   arg3 = &temp3;
8930   {
8931     try {
8932       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (Dali::DaliException e) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8944       };
8945     } catch (...) {
8946       {
8947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8948       };
8949     }
8950   }
8951
8952   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8953   return jresult;
8954 }
8955
8956
8957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8958   void * jresult ;
8959   Dali::Uint16Pair *result = 0 ;
8960
8961   {
8962     try {
8963       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8964     } catch (std::out_of_range& e) {
8965       {
8966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (std::exception& e) {
8969       {
8970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8971       };
8972     } catch (Dali::DaliException e) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8975       };
8976     } catch (...) {
8977       {
8978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8979       };
8980     }
8981   }
8982
8983   jresult = (void *)result;
8984   return jresult;
8985 }
8986
8987
8988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8989   void * jresult ;
8990   uint32_t arg1 ;
8991   uint32_t arg2 ;
8992   Dali::Uint16Pair *result = 0 ;
8993
8994   arg1 = (uint32_t)jarg1;
8995   arg2 = (uint32_t)jarg2;
8996   {
8997     try {
8998       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8999     } catch (std::out_of_range& e) {
9000       {
9001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9002       };
9003     } catch (std::exception& e) {
9004       {
9005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9006       };
9007     } catch (Dali::DaliException e) {
9008       {
9009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9010       };
9011     } catch (...) {
9012       {
9013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9014       };
9015     }
9016   }
9017
9018   jresult = (void *)result;
9019   return jresult;
9020 }
9021
9022
9023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9024   void * jresult ;
9025   Dali::Uint16Pair *arg1 = 0 ;
9026   Dali::Uint16Pair *result = 0 ;
9027
9028   arg1 = (Dali::Uint16Pair *)jarg1;
9029   if (!arg1) {
9030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9031     return 0;
9032   }
9033   {
9034     try {
9035       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9036     } catch (std::out_of_range& e) {
9037       {
9038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9039       };
9040     } catch (std::exception& e) {
9041       {
9042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9043       };
9044     } catch (Dali::DaliException e) {
9045       {
9046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9047       };
9048     } catch (...) {
9049       {
9050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9051       };
9052     }
9053   }
9054
9055   jresult = (void *)result;
9056   return jresult;
9057 }
9058
9059
9060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9061   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9062   uint16_t arg2 ;
9063
9064   arg1 = (Dali::Uint16Pair *)jarg1;
9065   arg2 = (uint16_t)jarg2;
9066   {
9067     try {
9068       (arg1)->SetWidth(arg2);
9069     } catch (std::out_of_range& e) {
9070       {
9071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9072       };
9073     } catch (std::exception& e) {
9074       {
9075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9076       };
9077     } catch (Dali::DaliException e) {
9078       {
9079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9080       };
9081     } catch (...) {
9082       {
9083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9084       };
9085     }
9086   }
9087
9088 }
9089
9090
9091 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9092   unsigned short jresult ;
9093   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9094   uint16_t result;
9095
9096   arg1 = (Dali::Uint16Pair *)jarg1;
9097   {
9098     try {
9099       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9100     } catch (std::out_of_range& e) {
9101       {
9102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9103       };
9104     } catch (std::exception& e) {
9105       {
9106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9107       };
9108     } catch (Dali::DaliException e) {
9109       {
9110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9111       };
9112     } catch (...) {
9113       {
9114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9115       };
9116     }
9117   }
9118
9119   jresult = result;
9120   return jresult;
9121 }
9122
9123
9124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9125   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9126   uint16_t arg2 ;
9127
9128   arg1 = (Dali::Uint16Pair *)jarg1;
9129   arg2 = (uint16_t)jarg2;
9130   {
9131     try {
9132       (arg1)->SetHeight(arg2);
9133     } catch (std::out_of_range& e) {
9134       {
9135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9136       };
9137     } catch (std::exception& e) {
9138       {
9139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9140       };
9141     } catch (Dali::DaliException e) {
9142       {
9143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9144       };
9145     } catch (...) {
9146       {
9147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9148       };
9149     }
9150   }
9151
9152 }
9153
9154
9155 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9156   unsigned short jresult ;
9157   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9158   uint16_t result;
9159
9160   arg1 = (Dali::Uint16Pair *)jarg1;
9161   {
9162     try {
9163       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9164     } catch (std::out_of_range& e) {
9165       {
9166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9167       };
9168     } catch (std::exception& e) {
9169       {
9170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9171       };
9172     } catch (Dali::DaliException e) {
9173       {
9174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9175       };
9176     } catch (...) {
9177       {
9178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9179       };
9180     }
9181   }
9182
9183   jresult = result;
9184   return jresult;
9185 }
9186
9187
9188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9189   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9190   uint16_t arg2 ;
9191
9192   arg1 = (Dali::Uint16Pair *)jarg1;
9193   arg2 = (uint16_t)jarg2;
9194   {
9195     try {
9196       (arg1)->SetX(arg2);
9197     } catch (std::out_of_range& e) {
9198       {
9199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9200       };
9201     } catch (std::exception& e) {
9202       {
9203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9204       };
9205     } catch (Dali::DaliException e) {
9206       {
9207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9208       };
9209     } catch (...) {
9210       {
9211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9212       };
9213     }
9214   }
9215
9216 }
9217
9218
9219 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9220   unsigned short jresult ;
9221   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9222   uint16_t result;
9223
9224   arg1 = (Dali::Uint16Pair *)jarg1;
9225   {
9226     try {
9227       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9228     } catch (std::out_of_range& e) {
9229       {
9230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9231       };
9232     } catch (std::exception& e) {
9233       {
9234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9235       };
9236     } catch (Dali::DaliException e) {
9237       {
9238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9239       };
9240     } catch (...) {
9241       {
9242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9243       };
9244     }
9245   }
9246
9247   jresult = result;
9248   return jresult;
9249 }
9250
9251
9252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9253   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9254   uint16_t arg2 ;
9255
9256   arg1 = (Dali::Uint16Pair *)jarg1;
9257   arg2 = (uint16_t)jarg2;
9258   {
9259     try {
9260       (arg1)->SetY(arg2);
9261     } catch (std::out_of_range& e) {
9262       {
9263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9264       };
9265     } catch (std::exception& e) {
9266       {
9267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9268       };
9269     } catch (Dali::DaliException e) {
9270       {
9271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9272       };
9273     } catch (...) {
9274       {
9275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9276       };
9277     }
9278   }
9279
9280 }
9281
9282
9283 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9284   unsigned short jresult ;
9285   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9286   uint16_t result;
9287
9288   arg1 = (Dali::Uint16Pair *)jarg1;
9289   {
9290     try {
9291       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9292     } catch (std::out_of_range& e) {
9293       {
9294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9295       };
9296     } catch (std::exception& e) {
9297       {
9298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9299       };
9300     } catch (Dali::DaliException e) {
9301       {
9302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9303       };
9304     } catch (...) {
9305       {
9306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9307       };
9308     }
9309   }
9310
9311   jresult = result;
9312   return jresult;
9313 }
9314
9315
9316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9317   void * jresult ;
9318   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9319   Dali::Uint16Pair *arg2 = 0 ;
9320   Dali::Uint16Pair *result = 0 ;
9321
9322   arg1 = (Dali::Uint16Pair *)jarg1;
9323   arg2 = (Dali::Uint16Pair *)jarg2;
9324   if (!arg2) {
9325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9326     return 0;
9327   }
9328   {
9329     try {
9330       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9331     } catch (std::out_of_range& e) {
9332       {
9333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9334       };
9335     } catch (std::exception& e) {
9336       {
9337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9338       };
9339     } catch (Dali::DaliException e) {
9340       {
9341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9342       };
9343     } catch (...) {
9344       {
9345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9346       };
9347     }
9348   }
9349
9350   jresult = (void *)result;
9351   return jresult;
9352 }
9353
9354
9355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9356   unsigned int jresult ;
9357   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9358   Dali::Uint16Pair *arg2 = 0 ;
9359   bool result;
9360
9361   arg1 = (Dali::Uint16Pair *)jarg1;
9362   arg2 = (Dali::Uint16Pair *)jarg2;
9363   if (!arg2) {
9364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9365     return 0;
9366   }
9367   {
9368     try {
9369       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9370     } catch (std::out_of_range& e) {
9371       {
9372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9373       };
9374     } catch (std::exception& e) {
9375       {
9376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9377       };
9378     } catch (Dali::DaliException e) {
9379       {
9380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9381       };
9382     } catch (...) {
9383       {
9384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9385       };
9386     }
9387   }
9388
9389   jresult = result;
9390   return jresult;
9391 }
9392
9393
9394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9395   unsigned int jresult ;
9396   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9397   Dali::Uint16Pair *arg2 = 0 ;
9398   bool result;
9399
9400   arg1 = (Dali::Uint16Pair *)jarg1;
9401   arg2 = (Dali::Uint16Pair *)jarg2;
9402   if (!arg2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9404     return 0;
9405   }
9406   {
9407     try {
9408       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9409     } catch (std::out_of_range& e) {
9410       {
9411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9412       };
9413     } catch (std::exception& e) {
9414       {
9415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9416       };
9417     } catch (Dali::DaliException e) {
9418       {
9419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9420       };
9421     } catch (...) {
9422       {
9423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9424       };
9425     }
9426   }
9427
9428   jresult = result;
9429   return jresult;
9430 }
9431
9432
9433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9434   unsigned int jresult ;
9435   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9436   Dali::Uint16Pair *arg2 = 0 ;
9437   bool result;
9438
9439   arg1 = (Dali::Uint16Pair *)jarg1;
9440   arg2 = (Dali::Uint16Pair *)jarg2;
9441   if (!arg2) {
9442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9443     return 0;
9444   }
9445   {
9446     try {
9447       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9448     } catch (std::out_of_range& e) {
9449       {
9450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9451       };
9452     } catch (std::exception& e) {
9453       {
9454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (Dali::DaliException e) {
9457       {
9458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466
9467   jresult = result;
9468   return jresult;
9469 }
9470
9471
9472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9473   unsigned int jresult ;
9474   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9475   Dali::Uint16Pair *arg2 = 0 ;
9476   bool result;
9477
9478   arg1 = (Dali::Uint16Pair *)jarg1;
9479   arg2 = (Dali::Uint16Pair *)jarg2;
9480   if (!arg2) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9482     return 0;
9483   }
9484   {
9485     try {
9486       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9487     } catch (std::out_of_range& e) {
9488       {
9489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9490       };
9491     } catch (std::exception& e) {
9492       {
9493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9494       };
9495     } catch (Dali::DaliException e) {
9496       {
9497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9498       };
9499     } catch (...) {
9500       {
9501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9502       };
9503     }
9504   }
9505
9506   jresult = result;
9507   return jresult;
9508 }
9509
9510
9511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9512   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9513
9514   arg1 = (Dali::Uint16Pair *)jarg1;
9515   {
9516     try {
9517       delete arg1;
9518     } catch (std::out_of_range& e) {
9519       {
9520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9521       };
9522     } catch (std::exception& e) {
9523       {
9524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9525       };
9526     } catch (Dali::DaliException e) {
9527       {
9528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9529       };
9530     } catch (...) {
9531       {
9532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9533       };
9534     }
9535   }
9536
9537 }
9538
9539
9540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9541   void * jresult ;
9542   Dali::Degree *result = 0 ;
9543
9544   {
9545     try {
9546       result = (Dali::Degree *)new Dali::Degree();
9547     } catch (std::out_of_range& e) {
9548       {
9549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9550       };
9551     } catch (std::exception& e) {
9552       {
9553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9554       };
9555     } catch (Dali::DaliException e) {
9556       {
9557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9558       };
9559     } catch (...) {
9560       {
9561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9562       };
9563     }
9564   }
9565
9566   jresult = (void *)result;
9567   return jresult;
9568 }
9569
9570
9571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9572   void * jresult ;
9573   float arg1 ;
9574   Dali::Degree *result = 0 ;
9575
9576   arg1 = (float)jarg1;
9577   {
9578     try {
9579       result = (Dali::Degree *)new Dali::Degree(arg1);
9580     } catch (std::out_of_range& e) {
9581       {
9582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9583       };
9584     } catch (std::exception& e) {
9585       {
9586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9587       };
9588     } catch (Dali::DaliException e) {
9589       {
9590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9591       };
9592     } catch (...) {
9593       {
9594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9595       };
9596     }
9597   }
9598
9599   jresult = (void *)result;
9600   return jresult;
9601 }
9602
9603
9604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9605   void * jresult ;
9606   Dali::Radian arg1 ;
9607   Dali::Radian *argp1 ;
9608   Dali::Degree *result = 0 ;
9609
9610   argp1 = (Dali::Radian *)jarg1;
9611   if (!argp1) {
9612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9613     return 0;
9614   }
9615   arg1 = *argp1;
9616   {
9617     try {
9618       result = (Dali::Degree *)new Dali::Degree(arg1);
9619     } catch (std::out_of_range& e) {
9620       {
9621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (std::exception& e) {
9624       {
9625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9626       };
9627     } catch (Dali::DaliException e) {
9628       {
9629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9630       };
9631     } catch (...) {
9632       {
9633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9634       };
9635     }
9636   }
9637
9638   jresult = (void *)result;
9639   return jresult;
9640 }
9641
9642
9643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9644   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9645   float arg2 ;
9646
9647   arg1 = (Dali::Degree *)jarg1;
9648   arg2 = (float)jarg2;
9649   if (arg1) (arg1)->degree = arg2;
9650 }
9651
9652
9653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9654   float jresult ;
9655   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9656   float result;
9657
9658   arg1 = (Dali::Degree *)jarg1;
9659   result = (float) ((arg1)->degree);
9660   jresult = result;
9661   return jresult;
9662 }
9663
9664
9665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9666   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9667
9668   arg1 = (Dali::Degree *)jarg1;
9669   {
9670     try {
9671       delete arg1;
9672     } catch (std::out_of_range& e) {
9673       {
9674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9675       };
9676     } catch (std::exception& e) {
9677       {
9678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9679       };
9680     } catch (Dali::DaliException e) {
9681       {
9682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9683       };
9684     } catch (...) {
9685       {
9686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9687       };
9688     }
9689   }
9690
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_360;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_315;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_270;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_225;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_180;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_135;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_120;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_90;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_60;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9785   void * jresult ;
9786   Dali::Radian *result = 0 ;
9787
9788   result = (Dali::Radian *)&Dali::ANGLE_45;
9789   jresult = (void *)result;
9790   return jresult;
9791 }
9792
9793
9794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9795   void * jresult ;
9796   Dali::Radian *result = 0 ;
9797
9798   result = (Dali::Radian *)&Dali::ANGLE_30;
9799   jresult = (void *)result;
9800   return jresult;
9801 }
9802
9803
9804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9805   void * jresult ;
9806   Dali::Radian *result = 0 ;
9807
9808   result = (Dali::Radian *)&Dali::ANGLE_0;
9809   jresult = (void *)result;
9810   return jresult;
9811 }
9812
9813
9814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9815   unsigned int jresult ;
9816   Dali::Degree *arg1 = 0 ;
9817   Dali::Degree *arg2 = 0 ;
9818   bool result;
9819
9820   arg1 = (Dali::Degree *)jarg1;
9821   if (!arg1) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9823     return 0;
9824   }
9825   arg2 = (Dali::Degree *)jarg2;
9826   if (!arg2) {
9827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9828     return 0;
9829   }
9830   {
9831     try {
9832       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9833     } catch (std::out_of_range& e) {
9834       {
9835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9836       };
9837     } catch (std::exception& e) {
9838       {
9839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (Dali::DaliException e) {
9842       {
9843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9844       };
9845     } catch (...) {
9846       {
9847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9848       };
9849     }
9850   }
9851
9852   jresult = result;
9853   return jresult;
9854 }
9855
9856
9857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9858   unsigned int jresult ;
9859   Dali::Degree *arg1 = 0 ;
9860   Dali::Degree *arg2 = 0 ;
9861   bool result;
9862
9863   arg1 = (Dali::Degree *)jarg1;
9864   if (!arg1) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9866     return 0;
9867   }
9868   arg2 = (Dali::Degree *)jarg2;
9869   if (!arg2) {
9870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9871     return 0;
9872   }
9873   {
9874     try {
9875       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9876     } catch (std::out_of_range& e) {
9877       {
9878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9879       };
9880     } catch (std::exception& e) {
9881       {
9882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9883       };
9884     } catch (Dali::DaliException e) {
9885       {
9886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9887       };
9888     } catch (...) {
9889       {
9890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9891       };
9892     }
9893   }
9894
9895   jresult = result;
9896   return jresult;
9897 }
9898
9899
9900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9901   void * jresult ;
9902   Dali::Degree arg1 ;
9903   float arg2 ;
9904   float arg3 ;
9905   Dali::Degree *argp1 ;
9906   Dali::Degree result;
9907
9908   argp1 = (Dali::Degree *)jarg1;
9909   if (!argp1) {
9910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9911     return 0;
9912   }
9913   arg1 = *argp1;
9914   arg2 = (float)jarg2;
9915   arg3 = (float)jarg3;
9916   {
9917     try {
9918       result = Dali::Clamp(arg1,arg2,arg3);
9919     } catch (std::out_of_range& e) {
9920       {
9921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9922       };
9923     } catch (std::exception& e) {
9924       {
9925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9926       };
9927     } catch (Dali::DaliException e) {
9928       {
9929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9930       };
9931     } catch (...) {
9932       {
9933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9934       };
9935     }
9936   }
9937
9938   jresult = new Dali::Degree((const Dali::Degree &)result);
9939   return jresult;
9940 }
9941
9942
9943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9944   void * jresult ;
9945   Dali::Radian *result = 0 ;
9946
9947   {
9948     try {
9949       result = (Dali::Radian *)new Dali::Radian();
9950     } catch (std::out_of_range& e) {
9951       {
9952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9953       };
9954     } catch (std::exception& e) {
9955       {
9956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9957       };
9958     } catch (Dali::DaliException e) {
9959       {
9960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9961       };
9962     } catch (...) {
9963       {
9964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9965       };
9966     }
9967   }
9968
9969   jresult = (void *)result;
9970   return jresult;
9971 }
9972
9973
9974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9975   void * jresult ;
9976   float arg1 ;
9977   Dali::Radian *result = 0 ;
9978
9979   arg1 = (float)jarg1;
9980   {
9981     try {
9982       result = (Dali::Radian *)new Dali::Radian(arg1);
9983     } catch (std::out_of_range& e) {
9984       {
9985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9986       };
9987     } catch (std::exception& e) {
9988       {
9989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9990       };
9991     } catch (Dali::DaliException e) {
9992       {
9993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9994       };
9995     } catch (...) {
9996       {
9997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9998       };
9999     }
10000   }
10001
10002   jresult = (void *)result;
10003   return jresult;
10004 }
10005
10006
10007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10008   void * jresult ;
10009   Dali::Degree arg1 ;
10010   Dali::Degree *argp1 ;
10011   Dali::Radian *result = 0 ;
10012
10013   argp1 = (Dali::Degree *)jarg1;
10014   if (!argp1) {
10015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10016     return 0;
10017   }
10018   arg1 = *argp1;
10019   {
10020     try {
10021       result = (Dali::Radian *)new Dali::Radian(arg1);
10022     } catch (std::out_of_range& e) {
10023       {
10024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10025       };
10026     } catch (std::exception& e) {
10027       {
10028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10029       };
10030     } catch (Dali::DaliException e) {
10031       {
10032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10033       };
10034     } catch (...) {
10035       {
10036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10037       };
10038     }
10039   }
10040
10041   jresult = (void *)result;
10042   return jresult;
10043 }
10044
10045
10046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10047   void * jresult ;
10048   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10049   float arg2 ;
10050   Dali::Radian *result = 0 ;
10051
10052   arg1 = (Dali::Radian *)jarg1;
10053   arg2 = (float)jarg2;
10054   {
10055     try {
10056       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10057     } catch (std::out_of_range& e) {
10058       {
10059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10060       };
10061     } catch (std::exception& e) {
10062       {
10063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10064       };
10065     } catch (Dali::DaliException e) {
10066       {
10067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10068       };
10069     } catch (...) {
10070       {
10071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10072       };
10073     }
10074   }
10075
10076   jresult = (void *)result;
10077   return jresult;
10078 }
10079
10080
10081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10082   void * jresult ;
10083   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10084   Dali::Degree arg2 ;
10085   Dali::Degree *argp2 ;
10086   Dali::Radian *result = 0 ;
10087
10088   arg1 = (Dali::Radian *)jarg1;
10089   argp2 = (Dali::Degree *)jarg2;
10090   if (!argp2) {
10091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10092     return 0;
10093   }
10094   arg2 = *argp2;
10095   {
10096     try {
10097       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10098     } catch (std::out_of_range& e) {
10099       {
10100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10101       };
10102     } catch (std::exception& e) {
10103       {
10104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10105       };
10106     } catch (Dali::DaliException e) {
10107       {
10108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10109       };
10110     } catch (...) {
10111       {
10112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10113       };
10114     }
10115   }
10116
10117   jresult = (void *)result;
10118   return jresult;
10119 }
10120
10121
10122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10123   float jresult ;
10124   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10125   float result;
10126
10127   arg1 = (Dali::Radian *)jarg1;
10128   {
10129     try {
10130       result = (float)((Dali::Radian const *)arg1)->operator float();
10131     } catch (std::out_of_range& e) {
10132       {
10133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10134       };
10135     } catch (std::exception& e) {
10136       {
10137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10138       };
10139     } catch (Dali::DaliException e) {
10140       {
10141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10142       };
10143     } catch (...) {
10144       {
10145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10146       };
10147     }
10148   }
10149
10150   jresult = result;
10151   return jresult;
10152 }
10153
10154
10155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10156   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10157   float arg2 ;
10158
10159   arg1 = (Dali::Radian *)jarg1;
10160   arg2 = (float)jarg2;
10161   if (arg1) (arg1)->radian = arg2;
10162 }
10163
10164
10165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10166   float jresult ;
10167   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10168   float result;
10169
10170   arg1 = (Dali::Radian *)jarg1;
10171   result = (float) ((arg1)->radian);
10172   jresult = result;
10173   return jresult;
10174 }
10175
10176
10177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10178   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10179
10180   arg1 = (Dali::Radian *)jarg1;
10181   {
10182     try {
10183       delete arg1;
10184     } catch (std::out_of_range& e) {
10185       {
10186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10187       };
10188     } catch (std::exception& e) {
10189       {
10190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10191       };
10192     } catch (Dali::DaliException e) {
10193       {
10194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10195       };
10196     } catch (...) {
10197       {
10198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10199       };
10200     }
10201   }
10202
10203 }
10204
10205
10206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10207   unsigned int jresult ;
10208   Dali::Radian arg1 ;
10209   Dali::Radian arg2 ;
10210   Dali::Radian *argp1 ;
10211   Dali::Radian *argp2 ;
10212   bool result;
10213
10214   argp1 = (Dali::Radian *)jarg1;
10215   if (!argp1) {
10216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10217     return 0;
10218   }
10219   arg1 = *argp1;
10220   argp2 = (Dali::Radian *)jarg2;
10221   if (!argp2) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10223     return 0;
10224   }
10225   arg2 = *argp2;
10226   {
10227     try {
10228       result = (bool)Dali::operator ==(arg1,arg2);
10229     } catch (std::out_of_range& e) {
10230       {
10231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (std::exception& e) {
10234       {
10235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10236       };
10237     } catch (Dali::DaliException e) {
10238       {
10239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10240       };
10241     } catch (...) {
10242       {
10243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10244       };
10245     }
10246   }
10247
10248   jresult = result;
10249   return jresult;
10250 }
10251
10252
10253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10254   unsigned int jresult ;
10255   Dali::Radian arg1 ;
10256   Dali::Radian arg2 ;
10257   Dali::Radian *argp1 ;
10258   Dali::Radian *argp2 ;
10259   bool result;
10260
10261   argp1 = (Dali::Radian *)jarg1;
10262   if (!argp1) {
10263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10264     return 0;
10265   }
10266   arg1 = *argp1;
10267   argp2 = (Dali::Radian *)jarg2;
10268   if (!argp2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10270     return 0;
10271   }
10272   arg2 = *argp2;
10273   {
10274     try {
10275       result = (bool)Dali::operator !=(arg1,arg2);
10276     } catch (std::out_of_range& e) {
10277       {
10278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10279       };
10280     } catch (std::exception& e) {
10281       {
10282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10283       };
10284     } catch (Dali::DaliException e) {
10285       {
10286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10287       };
10288     } catch (...) {
10289       {
10290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10291       };
10292     }
10293   }
10294
10295   jresult = result;
10296   return jresult;
10297 }
10298
10299
10300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10301   unsigned int jresult ;
10302   Dali::Radian arg1 ;
10303   Dali::Degree arg2 ;
10304   Dali::Radian *argp1 ;
10305   Dali::Degree *argp2 ;
10306   bool result;
10307
10308   argp1 = (Dali::Radian *)jarg1;
10309   if (!argp1) {
10310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10311     return 0;
10312   }
10313   arg1 = *argp1;
10314   argp2 = (Dali::Degree *)jarg2;
10315   if (!argp2) {
10316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10317     return 0;
10318   }
10319   arg2 = *argp2;
10320   {
10321     try {
10322       result = (bool)Dali::operator ==(arg1,arg2);
10323     } catch (std::out_of_range& e) {
10324       {
10325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10326       };
10327     } catch (std::exception& e) {
10328       {
10329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (Dali::DaliException e) {
10332       {
10333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10334       };
10335     } catch (...) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10338       };
10339     }
10340   }
10341
10342   jresult = result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10348   unsigned int jresult ;
10349   Dali::Radian arg1 ;
10350   Dali::Degree arg2 ;
10351   Dali::Radian *argp1 ;
10352   Dali::Degree *argp2 ;
10353   bool result;
10354
10355   argp1 = (Dali::Radian *)jarg1;
10356   if (!argp1) {
10357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10358     return 0;
10359   }
10360   arg1 = *argp1;
10361   argp2 = (Dali::Degree *)jarg2;
10362   if (!argp2) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10364     return 0;
10365   }
10366   arg2 = *argp2;
10367   {
10368     try {
10369       result = (bool)Dali::operator !=(arg1,arg2);
10370     } catch (std::out_of_range& e) {
10371       {
10372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10373       };
10374     } catch (std::exception& e) {
10375       {
10376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10377       };
10378     } catch (Dali::DaliException e) {
10379       {
10380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10381       };
10382     } catch (...) {
10383       {
10384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10385       };
10386     }
10387   }
10388
10389   jresult = result;
10390   return jresult;
10391 }
10392
10393
10394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10395   unsigned int jresult ;
10396   Dali::Degree arg1 ;
10397   Dali::Radian arg2 ;
10398   Dali::Degree *argp1 ;
10399   Dali::Radian *argp2 ;
10400   bool result;
10401
10402   argp1 = (Dali::Degree *)jarg1;
10403   if (!argp1) {
10404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10405     return 0;
10406   }
10407   arg1 = *argp1;
10408   argp2 = (Dali::Radian *)jarg2;
10409   if (!argp2) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10411     return 0;
10412   }
10413   arg2 = *argp2;
10414   {
10415     try {
10416       result = (bool)Dali::operator ==(arg1,arg2);
10417     } catch (std::out_of_range& e) {
10418       {
10419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10420       };
10421     } catch (std::exception& e) {
10422       {
10423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10424       };
10425     } catch (Dali::DaliException e) {
10426       {
10427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10428       };
10429     } catch (...) {
10430       {
10431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10432       };
10433     }
10434   }
10435
10436   jresult = result;
10437   return jresult;
10438 }
10439
10440
10441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10442   unsigned int jresult ;
10443   Dali::Degree arg1 ;
10444   Dali::Radian arg2 ;
10445   Dali::Degree *argp1 ;
10446   Dali::Radian *argp2 ;
10447   bool result;
10448
10449   argp1 = (Dali::Degree *)jarg1;
10450   if (!argp1) {
10451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10452     return 0;
10453   }
10454   arg1 = *argp1;
10455   argp2 = (Dali::Radian *)jarg2;
10456   if (!argp2) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10458     return 0;
10459   }
10460   arg2 = *argp2;
10461   {
10462     try {
10463       result = (bool)Dali::operator !=(arg1,arg2);
10464     } catch (std::out_of_range& e) {
10465       {
10466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10467       };
10468     } catch (std::exception& e) {
10469       {
10470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10471       };
10472     } catch (Dali::DaliException e) {
10473       {
10474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10475       };
10476     } catch (...) {
10477       {
10478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10479       };
10480     }
10481   }
10482
10483   jresult = result;
10484   return jresult;
10485 }
10486
10487
10488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10489   unsigned int jresult ;
10490   Dali::Radian arg1 ;
10491   Dali::Radian arg2 ;
10492   Dali::Radian *argp1 ;
10493   Dali::Radian *argp2 ;
10494   bool result;
10495
10496   argp1 = (Dali::Radian *)jarg1;
10497   if (!argp1) {
10498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10499     return 0;
10500   }
10501   arg1 = *argp1;
10502   argp2 = (Dali::Radian *)jarg2;
10503   if (!argp2) {
10504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10505     return 0;
10506   }
10507   arg2 = *argp2;
10508   {
10509     try {
10510       result = (bool)Dali::operator >(arg1,arg2);
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (Dali::DaliException e) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10522       };
10523     } catch (...) {
10524       {
10525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10526       };
10527     }
10528   }
10529
10530   jresult = result;
10531   return jresult;
10532 }
10533
10534
10535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10536   unsigned int jresult ;
10537   Dali::Radian arg1 ;
10538   Dali::Degree arg2 ;
10539   Dali::Radian *argp1 ;
10540   Dali::Degree *argp2 ;
10541   bool result;
10542
10543   argp1 = (Dali::Radian *)jarg1;
10544   if (!argp1) {
10545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10546     return 0;
10547   }
10548   arg1 = *argp1;
10549   argp2 = (Dali::Degree *)jarg2;
10550   if (!argp2) {
10551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10552     return 0;
10553   }
10554   arg2 = *argp2;
10555   {
10556     try {
10557       result = (bool)Dali::operator >(arg1,arg2);
10558     } catch (std::out_of_range& e) {
10559       {
10560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10561       };
10562     } catch (std::exception& e) {
10563       {
10564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10565       };
10566     } catch (Dali::DaliException e) {
10567       {
10568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10569       };
10570     } catch (...) {
10571       {
10572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10573       };
10574     }
10575   }
10576
10577   jresult = result;
10578   return jresult;
10579 }
10580
10581
10582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10583   unsigned int jresult ;
10584   Dali::Degree arg1 ;
10585   Dali::Radian arg2 ;
10586   Dali::Degree *argp1 ;
10587   Dali::Radian *argp2 ;
10588   bool result;
10589
10590   argp1 = (Dali::Degree *)jarg1;
10591   if (!argp1) {
10592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10593     return 0;
10594   }
10595   arg1 = *argp1;
10596   argp2 = (Dali::Radian *)jarg2;
10597   if (!argp2) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10599     return 0;
10600   }
10601   arg2 = *argp2;
10602   {
10603     try {
10604       result = (bool)Dali::operator >(arg1,arg2);
10605     } catch (std::out_of_range& e) {
10606       {
10607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10608       };
10609     } catch (std::exception& e) {
10610       {
10611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10612       };
10613     } catch (Dali::DaliException e) {
10614       {
10615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10616       };
10617     } catch (...) {
10618       {
10619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10620       };
10621     }
10622   }
10623
10624   jresult = result;
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10630   unsigned int jresult ;
10631   Dali::Radian arg1 ;
10632   Dali::Radian arg2 ;
10633   Dali::Radian *argp1 ;
10634   Dali::Radian *argp2 ;
10635   bool result;
10636
10637   argp1 = (Dali::Radian *)jarg1;
10638   if (!argp1) {
10639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10640     return 0;
10641   }
10642   arg1 = *argp1;
10643   argp2 = (Dali::Radian *)jarg2;
10644   if (!argp2) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10646     return 0;
10647   }
10648   arg2 = *argp2;
10649   {
10650     try {
10651       result = (bool)Dali::operator <(arg1,arg2);
10652     } catch (std::out_of_range& e) {
10653       {
10654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10655       };
10656     } catch (std::exception& e) {
10657       {
10658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (Dali::DaliException e) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670
10671   jresult = result;
10672   return jresult;
10673 }
10674
10675
10676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10677   unsigned int jresult ;
10678   Dali::Radian arg1 ;
10679   Dali::Degree arg2 ;
10680   Dali::Radian *argp1 ;
10681   Dali::Degree *argp2 ;
10682   bool result;
10683
10684   argp1 = (Dali::Radian *)jarg1;
10685   if (!argp1) {
10686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10687     return 0;
10688   }
10689   arg1 = *argp1;
10690   argp2 = (Dali::Degree *)jarg2;
10691   if (!argp2) {
10692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10693     return 0;
10694   }
10695   arg2 = *argp2;
10696   {
10697     try {
10698       result = (bool)Dali::operator <(arg1,arg2);
10699     } catch (std::out_of_range& e) {
10700       {
10701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10702       };
10703     } catch (std::exception& e) {
10704       {
10705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10706       };
10707     } catch (Dali::DaliException e) {
10708       {
10709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10710       };
10711     } catch (...) {
10712       {
10713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10714       };
10715     }
10716   }
10717
10718   jresult = result;
10719   return jresult;
10720 }
10721
10722
10723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10724   unsigned int jresult ;
10725   Dali::Degree arg1 ;
10726   Dali::Radian arg2 ;
10727   Dali::Degree *argp1 ;
10728   Dali::Radian *argp2 ;
10729   bool result;
10730
10731   argp1 = (Dali::Degree *)jarg1;
10732   if (!argp1) {
10733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10734     return 0;
10735   }
10736   arg1 = *argp1;
10737   argp2 = (Dali::Radian *)jarg2;
10738   if (!argp2) {
10739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10740     return 0;
10741   }
10742   arg2 = *argp2;
10743   {
10744     try {
10745       result = (bool)Dali::operator <(arg1,arg2);
10746     } catch (std::out_of_range& e) {
10747       {
10748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10749       };
10750     } catch (std::exception& e) {
10751       {
10752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10753       };
10754     } catch (Dali::DaliException e) {
10755       {
10756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10757       };
10758     } catch (...) {
10759       {
10760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10761       };
10762     }
10763   }
10764
10765   jresult = result;
10766   return jresult;
10767 }
10768
10769
10770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10771   void * jresult ;
10772   Dali::Radian arg1 ;
10773   float arg2 ;
10774   Dali::Radian *argp1 ;
10775   Dali::Radian result;
10776
10777   argp1 = (Dali::Radian *)jarg1;
10778   if (!argp1) {
10779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10780     return 0;
10781   }
10782   arg1 = *argp1;
10783   arg2 = (float)jarg2;
10784   {
10785     try {
10786       result = Dali::operator *(arg1,arg2);
10787     } catch (std::out_of_range& e) {
10788       {
10789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10790       };
10791     } catch (std::exception& e) {
10792       {
10793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10794       };
10795     } catch (Dali::DaliException e) {
10796       {
10797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10798       };
10799     } catch (...) {
10800       {
10801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10802       };
10803     }
10804   }
10805
10806   jresult = new Dali::Radian((const Dali::Radian &)result);
10807   return jresult;
10808 }
10809
10810
10811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10812   void * jresult ;
10813   Dali::Radian arg1 ;
10814   Dali::Radian *argp1 ;
10815   Dali::Radian result;
10816
10817   argp1 = (Dali::Radian *)jarg1;
10818   if (!argp1) {
10819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10820     return 0;
10821   }
10822   arg1 = *argp1;
10823   {
10824     try {
10825       result = Dali::operator -(arg1);
10826     } catch (std::out_of_range& e) {
10827       {
10828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10829       };
10830     } catch (std::exception& e) {
10831       {
10832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10833       };
10834     } catch (Dali::DaliException e) {
10835       {
10836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10837       };
10838     } catch (...) {
10839       {
10840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10841       };
10842     }
10843   }
10844
10845   jresult = new Dali::Radian((const Dali::Radian &)result);
10846   return jresult;
10847 }
10848
10849
10850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10851   void * jresult ;
10852   Dali::Radian arg1 ;
10853   float arg2 ;
10854   float arg3 ;
10855   Dali::Radian *argp1 ;
10856   Dali::Radian result;
10857
10858   argp1 = (Dali::Radian *)jarg1;
10859   if (!argp1) {
10860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10861     return 0;
10862   }
10863   arg1 = *argp1;
10864   arg2 = (float)jarg2;
10865   arg3 = (float)jarg3;
10866   {
10867     try {
10868       result = Dali::Clamp(arg1,arg2,arg3);
10869     } catch (std::out_of_range& e) {
10870       {
10871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10872       };
10873     } catch (std::exception& e) {
10874       {
10875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10876       };
10877     } catch (Dali::DaliException e) {
10878       {
10879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10880       };
10881     } catch (...) {
10882       {
10883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10884       };
10885     }
10886   }
10887
10888   jresult = new Dali::Radian((const Dali::Radian &)result);
10889   return jresult;
10890 }
10891
10892
10893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10894   void * jresult ;
10895   Dali::Quaternion *result = 0 ;
10896
10897   {
10898     try {
10899       result = (Dali::Quaternion *)new Dali::Quaternion();
10900     } catch (std::out_of_range& e) {
10901       {
10902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10903       };
10904     } catch (std::exception& e) {
10905       {
10906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10907       };
10908     } catch (Dali::DaliException e) {
10909       {
10910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10911       };
10912     } catch (...) {
10913       {
10914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10915       };
10916     }
10917   }
10918
10919   jresult = (void *)result;
10920   return jresult;
10921 }
10922
10923
10924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10925   void * jresult ;
10926   Dali::Radian arg1 ;
10927   Dali::Vector3 *arg2 = 0 ;
10928   Dali::Radian *argp1 ;
10929   Dali::Quaternion *result = 0 ;
10930
10931   argp1 = (Dali::Radian *)jarg1;
10932   if (!argp1) {
10933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10934     return 0;
10935   }
10936   arg1 = *argp1;
10937   arg2 = (Dali::Vector3 *)jarg2;
10938   if (!arg2) {
10939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10940     return 0;
10941   }
10942   {
10943     try {
10944       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10945     } catch (std::out_of_range& e) {
10946       {
10947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10948       };
10949     } catch (std::exception& e) {
10950       {
10951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10952       };
10953     } catch (Dali::DaliException e) {
10954       {
10955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10956       };
10957     } catch (...) {
10958       {
10959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10960       };
10961     }
10962   }
10963
10964   jresult = (void *)result;
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10970   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10971
10972   arg1 = (Dali::Quaternion *)jarg1;
10973   {
10974     try {
10975       delete arg1;
10976     } catch (std::out_of_range& e) {
10977       {
10978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10979       };
10980     } catch (std::exception& e) {
10981       {
10982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10983       };
10984     } catch (Dali::DaliException e) {
10985       {
10986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10987       };
10988     } catch (...) {
10989       {
10990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10991       };
10992     }
10993   }
10994
10995 }
10996
10997
10998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10999   void * jresult ;
11000   Dali::Quaternion *result = 0 ;
11001
11002   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11003   jresult = (void *)result;
11004   return jresult;
11005 }
11006
11007
11008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11009   unsigned int jresult ;
11010   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11011   bool result;
11012
11013   arg1 = (Dali::Quaternion *)jarg1;
11014   {
11015     try {
11016       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11017     } catch (std::out_of_range& e) {
11018       {
11019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11020       };
11021     } catch (std::exception& e) {
11022       {
11023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11024       };
11025     } catch (Dali::DaliException e) {
11026       {
11027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11028       };
11029     } catch (...) {
11030       {
11031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11032       };
11033     }
11034   }
11035
11036   jresult = result;
11037   return jresult;
11038 }
11039
11040
11041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11042   unsigned int jresult ;
11043   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11044   Dali::Vector3 *arg2 = 0 ;
11045   Dali::Radian *arg3 = 0 ;
11046   bool result;
11047
11048   arg1 = (Dali::Quaternion *)jarg1;
11049   arg2 = (Dali::Vector3 *)jarg2;
11050   if (!arg2) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11052     return 0;
11053   }
11054   arg3 = (Dali::Radian *)jarg3;
11055   if (!arg3) {
11056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11057     return 0;
11058   }
11059   {
11060     try {
11061       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11062     } catch (std::out_of_range& e) {
11063       {
11064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11065       };
11066     } catch (std::exception& e) {
11067       {
11068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11069       };
11070     } catch (Dali::DaliException e) {
11071       {
11072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11073       };
11074     } catch (...) {
11075       {
11076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11077       };
11078     }
11079   }
11080
11081   jresult = result;
11082   return jresult;
11083 }
11084
11085
11086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11087   void * jresult ;
11088   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11089   Dali::Quaternion *arg2 = 0 ;
11090   Dali::Quaternion result;
11091
11092   arg1 = (Dali::Quaternion *)jarg1;
11093   arg2 = (Dali::Quaternion *)jarg2;
11094   if (!arg2) {
11095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11096     return 0;
11097   }
11098   {
11099     try {
11100       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11101     } catch (std::out_of_range& e) {
11102       {
11103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11104       };
11105     } catch (std::exception& e) {
11106       {
11107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11108       };
11109     } catch (Dali::DaliException e) {
11110       {
11111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11112       };
11113     } catch (...) {
11114       {
11115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11116       };
11117     }
11118   }
11119
11120   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11121   return jresult;
11122 }
11123
11124
11125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11126   void * jresult ;
11127   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11128   Dali::Quaternion *arg2 = 0 ;
11129   Dali::Quaternion result;
11130
11131   arg1 = (Dali::Quaternion *)jarg1;
11132   arg2 = (Dali::Quaternion *)jarg2;
11133   if (!arg2) {
11134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11135     return 0;
11136   }
11137   {
11138     try {
11139       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11140     } catch (std::out_of_range& e) {
11141       {
11142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11143       };
11144     } catch (std::exception& e) {
11145       {
11146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11147       };
11148     } catch (Dali::DaliException e) {
11149       {
11150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11151       };
11152     } catch (...) {
11153       {
11154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11155       };
11156     }
11157   }
11158
11159   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11160   return jresult;
11161 }
11162
11163
11164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11165   void * jresult ;
11166   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11167   Dali::Quaternion *arg2 = 0 ;
11168   Dali::Quaternion result;
11169
11170   arg1 = (Dali::Quaternion *)jarg1;
11171   arg2 = (Dali::Quaternion *)jarg2;
11172   if (!arg2) {
11173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11174     return 0;
11175   }
11176   {
11177     try {
11178       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11179     } catch (std::out_of_range& e) {
11180       {
11181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11182       };
11183     } catch (std::exception& e) {
11184       {
11185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11186       };
11187     } catch (Dali::DaliException e) {
11188       {
11189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11190       };
11191     } catch (...) {
11192       {
11193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11194       };
11195     }
11196   }
11197
11198   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11199   return jresult;
11200 }
11201
11202
11203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11204   void * jresult ;
11205   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11206   Dali::Vector3 *arg2 = 0 ;
11207   Dali::Vector3 result;
11208
11209   arg1 = (Dali::Quaternion *)jarg1;
11210   arg2 = (Dali::Vector3 *)jarg2;
11211   if (!arg2) {
11212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11213     return 0;
11214   }
11215   {
11216     try {
11217       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11218     } catch (std::out_of_range& e) {
11219       {
11220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11221       };
11222     } catch (std::exception& e) {
11223       {
11224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11225       };
11226     } catch (Dali::DaliException e) {
11227       {
11228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11229       };
11230     } catch (...) {
11231       {
11232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11233       };
11234     }
11235   }
11236
11237   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11238   return jresult;
11239 }
11240
11241
11242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11243   void * jresult ;
11244   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11245   Dali::Quaternion *arg2 = 0 ;
11246   Dali::Quaternion result;
11247
11248   arg1 = (Dali::Quaternion *)jarg1;
11249   arg2 = (Dali::Quaternion *)jarg2;
11250   if (!arg2) {
11251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11252     return 0;
11253   }
11254   {
11255     try {
11256       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11257     } catch (std::out_of_range& e) {
11258       {
11259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11260       };
11261     } catch (std::exception& e) {
11262       {
11263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11264       };
11265     } catch (Dali::DaliException e) {
11266       {
11267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11268       };
11269     } catch (...) {
11270       {
11271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11272       };
11273     }
11274   }
11275
11276   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11277   return jresult;
11278 }
11279
11280
11281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11282   void * jresult ;
11283   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11284   float arg2 ;
11285   Dali::Quaternion result;
11286
11287   arg1 = (Dali::Quaternion *)jarg1;
11288   arg2 = (float)jarg2;
11289   {
11290     try {
11291       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11292     } catch (std::out_of_range& e) {
11293       {
11294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11295       };
11296     } catch (std::exception& e) {
11297       {
11298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11299       };
11300     } catch (Dali::DaliException e) {
11301       {
11302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11303       };
11304     } catch (...) {
11305       {
11306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11307       };
11308     }
11309   }
11310
11311   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11312   return jresult;
11313 }
11314
11315
11316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11317   void * jresult ;
11318   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11319   float arg2 ;
11320   Dali::Quaternion result;
11321
11322   arg1 = (Dali::Quaternion *)jarg1;
11323   arg2 = (float)jarg2;
11324   {
11325     try {
11326       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11327     } catch (std::out_of_range& e) {
11328       {
11329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11330       };
11331     } catch (std::exception& e) {
11332       {
11333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11334       };
11335     } catch (Dali::DaliException e) {
11336       {
11337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11338       };
11339     } catch (...) {
11340       {
11341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11342       };
11343     }
11344   }
11345
11346   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11347   return jresult;
11348 }
11349
11350
11351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11352   void * jresult ;
11353   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11354   Dali::Quaternion result;
11355
11356   arg1 = (Dali::Quaternion *)jarg1;
11357   {
11358     try {
11359       result = ((Dali::Quaternion const *)arg1)->operator -();
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11367       };
11368     } catch (Dali::DaliException e) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11371       };
11372     } catch (...) {
11373       {
11374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11375       };
11376     }
11377   }
11378
11379   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11380   return jresult;
11381 }
11382
11383
11384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11385   void * jresult ;
11386   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11387   Dali::Quaternion *arg2 = 0 ;
11388   Dali::Quaternion *result = 0 ;
11389
11390   arg1 = (Dali::Quaternion *)jarg1;
11391   arg2 = (Dali::Quaternion *)jarg2;
11392   if (!arg2) {
11393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11394     return 0;
11395   }
11396   {
11397     try {
11398       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11399     } catch (std::out_of_range& e) {
11400       {
11401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11402       };
11403     } catch (std::exception& e) {
11404       {
11405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11406       };
11407     } catch (Dali::DaliException e) {
11408       {
11409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11410       };
11411     } catch (...) {
11412       {
11413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11414       };
11415     }
11416   }
11417
11418   jresult = (void *)result;
11419   return jresult;
11420 }
11421
11422
11423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11424   void * jresult ;
11425   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11426   Dali::Quaternion *arg2 = 0 ;
11427   Dali::Quaternion *result = 0 ;
11428
11429   arg1 = (Dali::Quaternion *)jarg1;
11430   arg2 = (Dali::Quaternion *)jarg2;
11431   if (!arg2) {
11432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11433     return 0;
11434   }
11435   {
11436     try {
11437       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11438     } catch (std::out_of_range& e) {
11439       {
11440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11441       };
11442     } catch (std::exception& e) {
11443       {
11444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11445       };
11446     } catch (Dali::DaliException e) {
11447       {
11448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11449       };
11450     } catch (...) {
11451       {
11452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11453       };
11454     }
11455   }
11456
11457   jresult = (void *)result;
11458   return jresult;
11459 }
11460
11461
11462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11463   void * jresult ;
11464   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11465   Dali::Quaternion *arg2 = 0 ;
11466   Dali::Quaternion *result = 0 ;
11467
11468   arg1 = (Dali::Quaternion *)jarg1;
11469   arg2 = (Dali::Quaternion *)jarg2;
11470   if (!arg2) {
11471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11472     return 0;
11473   }
11474   {
11475     try {
11476       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11477     } catch (std::out_of_range& e) {
11478       {
11479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11480       };
11481     } catch (std::exception& e) {
11482       {
11483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11484       };
11485     } catch (Dali::DaliException e) {
11486       {
11487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11488       };
11489     } catch (...) {
11490       {
11491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11492       };
11493     }
11494   }
11495
11496   jresult = (void *)result;
11497   return jresult;
11498 }
11499
11500
11501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11502   void * jresult ;
11503   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11504   float arg2 ;
11505   Dali::Quaternion *result = 0 ;
11506
11507   arg1 = (Dali::Quaternion *)jarg1;
11508   arg2 = (float)jarg2;
11509   {
11510     try {
11511       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11512     } catch (std::out_of_range& e) {
11513       {
11514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11515       };
11516     } catch (std::exception& e) {
11517       {
11518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11519       };
11520     } catch (Dali::DaliException e) {
11521       {
11522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11523       };
11524     } catch (...) {
11525       {
11526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11527       };
11528     }
11529   }
11530
11531   jresult = (void *)result;
11532   return jresult;
11533 }
11534
11535
11536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11537   void * jresult ;
11538   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11539   float arg2 ;
11540   Dali::Quaternion *result = 0 ;
11541
11542   arg1 = (Dali::Quaternion *)jarg1;
11543   arg2 = (float)jarg2;
11544   {
11545     try {
11546       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11547     } catch (std::out_of_range& e) {
11548       {
11549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11550       };
11551     } catch (std::exception& e) {
11552       {
11553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11554       };
11555     } catch (Dali::DaliException e) {
11556       {
11557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11558       };
11559     } catch (...) {
11560       {
11561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11562       };
11563     }
11564   }
11565
11566   jresult = (void *)result;
11567   return jresult;
11568 }
11569
11570
11571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11572   unsigned int jresult ;
11573   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11574   Dali::Quaternion *arg2 = 0 ;
11575   bool result;
11576
11577   arg1 = (Dali::Quaternion *)jarg1;
11578   arg2 = (Dali::Quaternion *)jarg2;
11579   if (!arg2) {
11580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11581     return 0;
11582   }
11583   {
11584     try {
11585       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11586     } catch (std::out_of_range& e) {
11587       {
11588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11589       };
11590     } catch (std::exception& e) {
11591       {
11592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11593       };
11594     } catch (Dali::DaliException e) {
11595       {
11596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11597       };
11598     } catch (...) {
11599       {
11600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11601       };
11602     }
11603   }
11604
11605   jresult = result;
11606   return jresult;
11607 }
11608
11609
11610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11611   unsigned int jresult ;
11612   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11613   Dali::Quaternion *arg2 = 0 ;
11614   bool result;
11615
11616   arg1 = (Dali::Quaternion *)jarg1;
11617   arg2 = (Dali::Quaternion *)jarg2;
11618   if (!arg2) {
11619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11620     return 0;
11621   }
11622   {
11623     try {
11624       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11625     } catch (std::out_of_range& e) {
11626       {
11627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11628       };
11629     } catch (std::exception& e) {
11630       {
11631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11632       };
11633     } catch (Dali::DaliException e) {
11634       {
11635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11636       };
11637     } catch (...) {
11638       {
11639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11640       };
11641     }
11642   }
11643
11644   jresult = result;
11645   return jresult;
11646 }
11647
11648
11649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11650   float jresult ;
11651   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11652   float result;
11653
11654   arg1 = (Dali::Quaternion *)jarg1;
11655   {
11656     try {
11657       result = (float)((Dali::Quaternion const *)arg1)->Length();
11658     } catch (std::out_of_range& e) {
11659       {
11660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11661       };
11662     } catch (std::exception& e) {
11663       {
11664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11665       };
11666     } catch (Dali::DaliException e) {
11667       {
11668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11669       };
11670     } catch (...) {
11671       {
11672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11673       };
11674     }
11675   }
11676
11677   jresult = result;
11678   return jresult;
11679 }
11680
11681
11682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11683   float jresult ;
11684   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11685   float result;
11686
11687   arg1 = (Dali::Quaternion *)jarg1;
11688   {
11689     try {
11690       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11691     } catch (std::out_of_range& e) {
11692       {
11693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11694       };
11695     } catch (std::exception& e) {
11696       {
11697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11698       };
11699     } catch (Dali::DaliException e) {
11700       {
11701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11702       };
11703     } catch (...) {
11704       {
11705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11706       };
11707     }
11708   }
11709
11710   jresult = result;
11711   return jresult;
11712 }
11713
11714
11715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11716   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11717
11718   arg1 = (Dali::Quaternion *)jarg1;
11719   {
11720     try {
11721       (arg1)->Normalize();
11722     } catch (std::out_of_range& e) {
11723       {
11724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11725       };
11726     } catch (std::exception& e) {
11727       {
11728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11729       };
11730     } catch (Dali::DaliException e) {
11731       {
11732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11733       };
11734     } catch (...) {
11735       {
11736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11737       };
11738     }
11739   }
11740
11741 }
11742
11743
11744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11745   void * jresult ;
11746   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11747   Dali::Quaternion result;
11748
11749   arg1 = (Dali::Quaternion *)jarg1;
11750   {
11751     try {
11752       result = ((Dali::Quaternion const *)arg1)->Normalized();
11753     } catch (std::out_of_range& e) {
11754       {
11755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11756       };
11757     } catch (std::exception& e) {
11758       {
11759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11760       };
11761     } catch (Dali::DaliException e) {
11762       {
11763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11764       };
11765     } catch (...) {
11766       {
11767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11768       };
11769     }
11770   }
11771
11772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11773   return jresult;
11774 }
11775
11776
11777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11778   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11779
11780   arg1 = (Dali::Quaternion *)jarg1;
11781   {
11782     try {
11783       (arg1)->Conjugate();
11784     } catch (std::out_of_range& e) {
11785       {
11786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11787       };
11788     } catch (std::exception& e) {
11789       {
11790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11791       };
11792     } catch (Dali::DaliException e) {
11793       {
11794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11795       };
11796     } catch (...) {
11797       {
11798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11799       };
11800     }
11801   }
11802
11803 }
11804
11805
11806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11807   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11808
11809   arg1 = (Dali::Quaternion *)jarg1;
11810   {
11811     try {
11812       (arg1)->Invert();
11813     } catch (std::out_of_range& e) {
11814       {
11815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11816       };
11817     } catch (std::exception& e) {
11818       {
11819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11820       };
11821     } catch (Dali::DaliException e) {
11822       {
11823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11824       };
11825     } catch (...) {
11826       {
11827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11828       };
11829     }
11830   }
11831
11832 }
11833
11834
11835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11836   void * jresult ;
11837   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11838   Dali::Quaternion result;
11839
11840   arg1 = (Dali::Quaternion *)jarg1;
11841   {
11842     try {
11843       result = ((Dali::Quaternion const *)arg1)->Log();
11844     } catch (std::out_of_range& e) {
11845       {
11846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11847       };
11848     } catch (std::exception& e) {
11849       {
11850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11851       };
11852     } catch (Dali::DaliException e) {
11853       {
11854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11855       };
11856     } catch (...) {
11857       {
11858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11859       };
11860     }
11861   }
11862
11863   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11864   return jresult;
11865 }
11866
11867
11868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11869   void * jresult ;
11870   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11871   Dali::Quaternion result;
11872
11873   arg1 = (Dali::Quaternion *)jarg1;
11874   {
11875     try {
11876       result = ((Dali::Quaternion const *)arg1)->Exp();
11877     } catch (std::out_of_range& e) {
11878       {
11879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11880       };
11881     } catch (std::exception& e) {
11882       {
11883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11884       };
11885     } catch (Dali::DaliException e) {
11886       {
11887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11888       };
11889     } catch (...) {
11890       {
11891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11892       };
11893     }
11894   }
11895
11896   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11897   return jresult;
11898 }
11899
11900
11901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11902   float jresult ;
11903   Dali::Quaternion *arg1 = 0 ;
11904   Dali::Quaternion *arg2 = 0 ;
11905   float result;
11906
11907   arg1 = (Dali::Quaternion *)jarg1;
11908   if (!arg1) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   arg2 = (Dali::Quaternion *)jarg2;
11913   if (!arg2) {
11914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11915     return 0;
11916   }
11917   {
11918     try {
11919       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11920     } catch (std::out_of_range& e) {
11921       {
11922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11923       };
11924     } catch (std::exception& e) {
11925       {
11926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11927       };
11928     } catch (Dali::DaliException e) {
11929       {
11930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11931       };
11932     } catch (...) {
11933       {
11934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11935       };
11936     }
11937   }
11938
11939   jresult = result;
11940   return jresult;
11941 }
11942
11943
11944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11945   void * jresult ;
11946   Dali::Quaternion *arg1 = 0 ;
11947   Dali::Quaternion *arg2 = 0 ;
11948   float arg3 ;
11949   Dali::Quaternion result;
11950
11951   arg1 = (Dali::Quaternion *)jarg1;
11952   if (!arg1) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg2 = (Dali::Quaternion *)jarg2;
11957   if (!arg2) {
11958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11959     return 0;
11960   }
11961   arg3 = (float)jarg3;
11962   {
11963     try {
11964       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11965     } catch (std::out_of_range& e) {
11966       {
11967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11968       };
11969     } catch (std::exception& e) {
11970       {
11971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11972       };
11973     } catch (Dali::DaliException e) {
11974       {
11975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11976       };
11977     } catch (...) {
11978       {
11979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11980       };
11981     }
11982   }
11983
11984   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11985   return jresult;
11986 }
11987
11988
11989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11990   void * jresult ;
11991   Dali::Quaternion *arg1 = 0 ;
11992   Dali::Quaternion *arg2 = 0 ;
11993   float arg3 ;
11994   Dali::Quaternion result;
11995
11996   arg1 = (Dali::Quaternion *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11999     return 0;
12000   }
12001   arg2 = (Dali::Quaternion *)jarg2;
12002   if (!arg2) {
12003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12004     return 0;
12005   }
12006   arg3 = (float)jarg3;
12007   {
12008     try {
12009       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12010     } catch (std::out_of_range& e) {
12011       {
12012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12013       };
12014     } catch (std::exception& e) {
12015       {
12016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12017       };
12018     } catch (Dali::DaliException e) {
12019       {
12020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12021       };
12022     } catch (...) {
12023       {
12024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12025       };
12026     }
12027   }
12028
12029   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12030   return jresult;
12031 }
12032
12033
12034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12035   void * jresult ;
12036   Dali::Quaternion *arg1 = 0 ;
12037   Dali::Quaternion *arg2 = 0 ;
12038   float arg3 ;
12039   Dali::Quaternion result;
12040
12041   arg1 = (Dali::Quaternion *)jarg1;
12042   if (!arg1) {
12043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12044     return 0;
12045   }
12046   arg2 = (Dali::Quaternion *)jarg2;
12047   if (!arg2) {
12048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12049     return 0;
12050   }
12051   arg3 = (float)jarg3;
12052   {
12053     try {
12054       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12055     } catch (std::out_of_range& e) {
12056       {
12057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12058       };
12059     } catch (std::exception& e) {
12060       {
12061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12062       };
12063     } catch (Dali::DaliException e) {
12064       {
12065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12066       };
12067     } catch (...) {
12068       {
12069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12070       };
12071     }
12072   }
12073
12074   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12075   return jresult;
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12080   void * jresult ;
12081   Dali::Quaternion *arg1 = 0 ;
12082   Dali::Quaternion *arg2 = 0 ;
12083   Dali::Quaternion *arg3 = 0 ;
12084   Dali::Quaternion *arg4 = 0 ;
12085   float arg5 ;
12086   Dali::Quaternion result;
12087
12088   arg1 = (Dali::Quaternion *)jarg1;
12089   if (!arg1) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg2 = (Dali::Quaternion *)jarg2;
12094   if (!arg2) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg3 = (Dali::Quaternion *)jarg3;
12099   if (!arg3) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg4 = (Dali::Quaternion *)jarg4;
12104   if (!arg4) {
12105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12106     return 0;
12107   }
12108   arg5 = (float)jarg5;
12109   {
12110     try {
12111       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12112     } catch (std::out_of_range& e) {
12113       {
12114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12115       };
12116     } catch (std::exception& e) {
12117       {
12118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (Dali::DaliException e) {
12121       {
12122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12123       };
12124     } catch (...) {
12125       {
12126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12127       };
12128     }
12129   }
12130
12131   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12132   return jresult;
12133 }
12134
12135
12136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12137   float jresult ;
12138   Dali::Quaternion *arg1 = 0 ;
12139   Dali::Quaternion *arg2 = 0 ;
12140   float result;
12141
12142   arg1 = (Dali::Quaternion *)jarg1;
12143   if (!arg1) {
12144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12145     return 0;
12146   }
12147   arg2 = (Dali::Quaternion *)jarg2;
12148   if (!arg2) {
12149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12150     return 0;
12151   }
12152   {
12153     try {
12154       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12155     } catch (std::out_of_range& e) {
12156       {
12157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12158       };
12159     } catch (std::exception& e) {
12160       {
12161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12162       };
12163     } catch (Dali::DaliException e) {
12164       {
12165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12170       };
12171     }
12172   }
12173
12174   jresult = result;
12175   return jresult;
12176 }
12177
12178
12179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12180   void * jresult ;
12181   Dali::Matrix *result = 0 ;
12182
12183   {
12184     try {
12185       result = (Dali::Matrix *)new Dali::Matrix();
12186     } catch (std::out_of_range& e) {
12187       {
12188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12189       };
12190     } catch (std::exception& e) {
12191       {
12192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12193       };
12194     } catch (Dali::DaliException e) {
12195       {
12196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12197       };
12198     } catch (...) {
12199       {
12200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12201       };
12202     }
12203   }
12204
12205   jresult = (void *)result;
12206   return jresult;
12207 }
12208
12209
12210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12211   void * jresult ;
12212   bool arg1 ;
12213   Dali::Matrix *result = 0 ;
12214
12215   arg1 = jarg1 ? true : false;
12216   {
12217     try {
12218       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12226       };
12227     } catch (Dali::DaliException e) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12230       };
12231     } catch (...) {
12232       {
12233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12234       };
12235     }
12236   }
12237
12238   jresult = (void *)result;
12239   return jresult;
12240 }
12241
12242
12243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12244   void * jresult ;
12245   float *arg1 = (float *) 0 ;
12246   Dali::Matrix *result = 0 ;
12247
12248   arg1 = jarg1;
12249   {
12250     try {
12251       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12252     } catch (std::out_of_range& e) {
12253       {
12254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12255       };
12256     } catch (std::exception& e) {
12257       {
12258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12259       };
12260     } catch (Dali::DaliException e) {
12261       {
12262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12263       };
12264     } catch (...) {
12265       {
12266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12267       };
12268     }
12269   }
12270
12271   jresult = (void *)result;
12272
12273
12274   return jresult;
12275 }
12276
12277
12278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12279   void * jresult ;
12280   Dali::Quaternion *arg1 = 0 ;
12281   Dali::Matrix *result = 0 ;
12282
12283   arg1 = (Dali::Quaternion *)jarg1;
12284   if (!arg1) {
12285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12286     return 0;
12287   }
12288   {
12289     try {
12290       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12291     } catch (std::out_of_range& e) {
12292       {
12293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12294       };
12295     } catch (std::exception& e) {
12296       {
12297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12298       };
12299     } catch (Dali::DaliException e) {
12300       {
12301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12302       };
12303     } catch (...) {
12304       {
12305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12306       };
12307     }
12308   }
12309
12310   jresult = (void *)result;
12311   return jresult;
12312 }
12313
12314
12315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12316   void * jresult ;
12317   Dali::Matrix *arg1 = 0 ;
12318   Dali::Matrix *result = 0 ;
12319
12320   arg1 = (Dali::Matrix *)jarg1;
12321   if (!arg1) {
12322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12323     return 0;
12324   }
12325   {
12326     try {
12327       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12328     } catch (std::out_of_range& e) {
12329       {
12330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (std::exception& e) {
12333       {
12334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12335       };
12336     } catch (Dali::DaliException e) {
12337       {
12338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12339       };
12340     } catch (...) {
12341       {
12342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12343       };
12344     }
12345   }
12346
12347   jresult = (void *)result;
12348   return jresult;
12349 }
12350
12351
12352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12353   void * jresult ;
12354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12355   Dali::Matrix *arg2 = 0 ;
12356   Dali::Matrix *result = 0 ;
12357
12358   arg1 = (Dali::Matrix *)jarg1;
12359   arg2 = (Dali::Matrix *)jarg2;
12360   if (!arg2) {
12361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12362     return 0;
12363   }
12364   {
12365     try {
12366       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12367     } catch (std::out_of_range& e) {
12368       {
12369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12370       };
12371     } catch (std::exception& e) {
12372       {
12373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12374       };
12375     } catch (Dali::DaliException e) {
12376       {
12377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12378       };
12379     } catch (...) {
12380       {
12381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12382       };
12383     }
12384   }
12385
12386   jresult = (void *)result;
12387   return jresult;
12388 }
12389
12390
12391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12392   void * jresult ;
12393   Dali::Matrix *result = 0 ;
12394
12395   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12396   jresult = (void *)result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12402   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12403
12404   arg1 = (Dali::Matrix *)jarg1;
12405   {
12406     try {
12407       (arg1)->SetIdentity();
12408     } catch (std::out_of_range& e) {
12409       {
12410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12411       };
12412     } catch (std::exception& e) {
12413       {
12414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12415       };
12416     } catch (Dali::DaliException e) {
12417       {
12418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12419       };
12420     } catch (...) {
12421       {
12422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12423       };
12424     }
12425   }
12426
12427 }
12428
12429
12430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12431   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12432   Dali::Vector3 *arg2 = 0 ;
12433
12434   arg1 = (Dali::Matrix *)jarg1;
12435   arg2 = (Dali::Vector3 *)jarg2;
12436   if (!arg2) {
12437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12438     return ;
12439   }
12440   {
12441     try {
12442       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12443     } catch (std::out_of_range& e) {
12444       {
12445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12446       };
12447     } catch (std::exception& e) {
12448       {
12449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12450       };
12451     } catch (Dali::DaliException e) {
12452       {
12453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12454       };
12455     } catch (...) {
12456       {
12457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12458       };
12459     }
12460   }
12461
12462 }
12463
12464
12465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12466   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12467   Dali::Matrix *arg2 = 0 ;
12468
12469   arg1 = (Dali::Matrix *)jarg1;
12470   arg2 = (Dali::Matrix *)jarg2;
12471   if (!arg2) {
12472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12473     return ;
12474   }
12475   {
12476     try {
12477       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12478     } catch (std::out_of_range& e) {
12479       {
12480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12481       };
12482     } catch (std::exception& e) {
12483       {
12484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12485       };
12486     } catch (Dali::DaliException e) {
12487       {
12488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12489       };
12490     } catch (...) {
12491       {
12492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12493       };
12494     }
12495   }
12496
12497 }
12498
12499
12500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12501   unsigned int jresult ;
12502   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12503   bool result;
12504
12505   arg1 = (Dali::Matrix *)jarg1;
12506   {
12507     try {
12508       result = (bool)(arg1)->Invert();
12509     } catch (std::out_of_range& e) {
12510       {
12511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12512       };
12513     } catch (std::exception& e) {
12514       {
12515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12516       };
12517     } catch (Dali::DaliException e) {
12518       {
12519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12520       };
12521     } catch (...) {
12522       {
12523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12524       };
12525     }
12526   }
12527
12528   jresult = result;
12529   return jresult;
12530 }
12531
12532
12533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12535
12536   arg1 = (Dali::Matrix *)jarg1;
12537   {
12538     try {
12539       (arg1)->Transpose();
12540     } catch (std::out_of_range& e) {
12541       {
12542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12543       };
12544     } catch (std::exception& e) {
12545       {
12546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12547       };
12548     } catch (Dali::DaliException e) {
12549       {
12550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12551       };
12552     } catch (...) {
12553       {
12554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12555       };
12556     }
12557   }
12558
12559 }
12560
12561
12562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12563   void * jresult ;
12564   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12565   Dali::Vector3 result;
12566
12567   arg1 = (Dali::Matrix *)jarg1;
12568   {
12569     try {
12570       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12571     } catch (std::out_of_range& e) {
12572       {
12573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12574       };
12575     } catch (std::exception& e) {
12576       {
12577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12578       };
12579     } catch (Dali::DaliException e) {
12580       {
12581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12582       };
12583     } catch (...) {
12584       {
12585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12586       };
12587     }
12588   }
12589
12590   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12591   return jresult;
12592 }
12593
12594
12595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12596   void * jresult ;
12597   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12598   Dali::Vector3 result;
12599
12600   arg1 = (Dali::Matrix *)jarg1;
12601   {
12602     try {
12603       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12604     } catch (std::out_of_range& e) {
12605       {
12606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12607       };
12608     } catch (std::exception& e) {
12609       {
12610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12611       };
12612     } catch (Dali::DaliException e) {
12613       {
12614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12615       };
12616     } catch (...) {
12617       {
12618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12619       };
12620     }
12621   }
12622
12623   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12624   return jresult;
12625 }
12626
12627
12628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12629   void * jresult ;
12630   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12631   Dali::Vector3 result;
12632
12633   arg1 = (Dali::Matrix *)jarg1;
12634   {
12635     try {
12636       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12637     } catch (std::out_of_range& e) {
12638       {
12639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12640       };
12641     } catch (std::exception& e) {
12642       {
12643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12644       };
12645     } catch (Dali::DaliException e) {
12646       {
12647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12648       };
12649     } catch (...) {
12650       {
12651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12652       };
12653     }
12654   }
12655
12656   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12657   return jresult;
12658 }
12659
12660
12661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12662   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12663   Dali::Vector3 *arg2 = 0 ;
12664
12665   arg1 = (Dali::Matrix *)jarg1;
12666   arg2 = (Dali::Vector3 *)jarg2;
12667   if (!arg2) {
12668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12669     return ;
12670   }
12671   {
12672     try {
12673       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12674     } catch (std::out_of_range& e) {
12675       {
12676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12677       };
12678     } catch (std::exception& e) {
12679       {
12680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12681       };
12682     } catch (Dali::DaliException e) {
12683       {
12684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12685       };
12686     } catch (...) {
12687       {
12688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12689       };
12690     }
12691   }
12692
12693 }
12694
12695
12696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12697   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12698   Dali::Vector3 *arg2 = 0 ;
12699
12700   arg1 = (Dali::Matrix *)jarg1;
12701   arg2 = (Dali::Vector3 *)jarg2;
12702   if (!arg2) {
12703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12704     return ;
12705   }
12706   {
12707     try {
12708       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12709     } catch (std::out_of_range& e) {
12710       {
12711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12712       };
12713     } catch (std::exception& e) {
12714       {
12715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12716       };
12717     } catch (Dali::DaliException e) {
12718       {
12719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12720       };
12721     } catch (...) {
12722       {
12723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12724       };
12725     }
12726   }
12727
12728 }
12729
12730
12731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12732   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12733   Dali::Vector3 *arg2 = 0 ;
12734
12735   arg1 = (Dali::Matrix *)jarg1;
12736   arg2 = (Dali::Vector3 *)jarg2;
12737   if (!arg2) {
12738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12739     return ;
12740   }
12741   {
12742     try {
12743       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12744     } catch (std::out_of_range& e) {
12745       {
12746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12747       };
12748     } catch (std::exception& e) {
12749       {
12750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12751       };
12752     } catch (Dali::DaliException e) {
12753       {
12754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12755       };
12756     } catch (...) {
12757       {
12758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12759       };
12760     }
12761   }
12762
12763 }
12764
12765
12766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12767   void * jresult ;
12768   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12769   Dali::Vector4 *result = 0 ;
12770
12771   arg1 = (Dali::Matrix *)jarg1;
12772   {
12773     try {
12774       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12775     } catch (std::out_of_range& e) {
12776       {
12777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12778       };
12779     } catch (std::exception& e) {
12780       {
12781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12782       };
12783     } catch (Dali::DaliException e) {
12784       {
12785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12786       };
12787     } catch (...) {
12788       {
12789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12790       };
12791     }
12792   }
12793
12794   jresult = (void *)result;
12795   return jresult;
12796 }
12797
12798
12799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12800   void * jresult ;
12801   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12802   Dali::Vector3 *result = 0 ;
12803
12804   arg1 = (Dali::Matrix *)jarg1;
12805   {
12806     try {
12807       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12808     } catch (std::out_of_range& e) {
12809       {
12810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (std::exception& e) {
12813       {
12814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (Dali::DaliException e) {
12817       {
12818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12819       };
12820     } catch (...) {
12821       {
12822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12823       };
12824     }
12825   }
12826
12827   jresult = (void *)result;
12828   return jresult;
12829 }
12830
12831
12832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12833   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12834   Dali::Vector4 *arg2 = 0 ;
12835
12836   arg1 = (Dali::Matrix *)jarg1;
12837   arg2 = (Dali::Vector4 *)jarg2;
12838   if (!arg2) {
12839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12840     return ;
12841   }
12842   {
12843     try {
12844       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12845     } catch (std::out_of_range& e) {
12846       {
12847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12848       };
12849     } catch (std::exception& e) {
12850       {
12851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12852       };
12853     } catch (Dali::DaliException e) {
12854       {
12855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12856       };
12857     } catch (...) {
12858       {
12859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12860       };
12861     }
12862   }
12863
12864 }
12865
12866
12867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12868   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12869   Dali::Vector3 *arg2 = 0 ;
12870
12871   arg1 = (Dali::Matrix *)jarg1;
12872   arg2 = (Dali::Vector3 *)jarg2;
12873   if (!arg2) {
12874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12875     return ;
12876   }
12877   {
12878     try {
12879       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12880     } catch (std::out_of_range& e) {
12881       {
12882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12883       };
12884     } catch (std::exception& e) {
12885       {
12886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12887       };
12888     } catch (Dali::DaliException e) {
12889       {
12890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12891       };
12892     } catch (...) {
12893       {
12894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12895       };
12896     }
12897   }
12898
12899 }
12900
12901
12902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12903   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12904
12905   arg1 = (Dali::Matrix *)jarg1;
12906   {
12907     try {
12908       (arg1)->OrthoNormalize();
12909     } catch (std::out_of_range& e) {
12910       {
12911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12912       };
12913     } catch (std::exception& e) {
12914       {
12915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12916       };
12917     } catch (Dali::DaliException e) {
12918       {
12919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12920       };
12921     } catch (...) {
12922       {
12923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12924       };
12925     }
12926   }
12927
12928 }
12929
12930
12931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12932   void * jresult ;
12933   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12934   float *result = 0 ;
12935
12936   arg1 = (Dali::Matrix *)jarg1;
12937   {
12938     try {
12939       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12940     } catch (std::out_of_range& e) {
12941       {
12942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (std::exception& e) {
12945       {
12946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12947       };
12948     } catch (Dali::DaliException e) {
12949       {
12950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12951       };
12952     } catch (...) {
12953       {
12954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12955       };
12956     }
12957   }
12958
12959   jresult = (void *)result;
12960   return jresult;
12961 }
12962
12963
12964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12965   Dali::Matrix *arg1 = 0 ;
12966   Dali::Matrix *arg2 = 0 ;
12967   Dali::Matrix *arg3 = 0 ;
12968
12969   arg1 = (Dali::Matrix *)jarg1;
12970   if (!arg1) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12972     return ;
12973   }
12974   arg2 = (Dali::Matrix *)jarg2;
12975   if (!arg2) {
12976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12977     return ;
12978   }
12979   arg3 = (Dali::Matrix *)jarg3;
12980   if (!arg3) {
12981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12982     return ;
12983   }
12984   {
12985     try {
12986       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12987     } catch (std::out_of_range& e) {
12988       {
12989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12990       };
12991     } catch (std::exception& e) {
12992       {
12993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12994       };
12995     } catch (Dali::DaliException e) {
12996       {
12997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12998       };
12999     } catch (...) {
13000       {
13001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13002       };
13003     }
13004   }
13005
13006 }
13007
13008
13009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13010   Dali::Matrix *arg1 = 0 ;
13011   Dali::Matrix *arg2 = 0 ;
13012   Dali::Quaternion *arg3 = 0 ;
13013
13014   arg1 = (Dali::Matrix *)jarg1;
13015   if (!arg1) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13017     return ;
13018   }
13019   arg2 = (Dali::Matrix *)jarg2;
13020   if (!arg2) {
13021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13022     return ;
13023   }
13024   arg3 = (Dali::Quaternion *)jarg3;
13025   if (!arg3) {
13026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13027     return ;
13028   }
13029   {
13030     try {
13031       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13032     } catch (std::out_of_range& e) {
13033       {
13034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13035       };
13036     } catch (std::exception& e) {
13037       {
13038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13039       };
13040     } catch (Dali::DaliException e) {
13041       {
13042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13043       };
13044     } catch (...) {
13045       {
13046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13047       };
13048     }
13049   }
13050
13051 }
13052
13053
13054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13055   void * jresult ;
13056   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13057   Dali::Vector4 *arg2 = 0 ;
13058   Dali::Vector4 result;
13059
13060   arg1 = (Dali::Matrix *)jarg1;
13061   arg2 = (Dali::Vector4 *)jarg2;
13062   if (!arg2) {
13063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13064     return 0;
13065   }
13066   {
13067     try {
13068       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13069     } catch (std::out_of_range& e) {
13070       {
13071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13072       };
13073     } catch (std::exception& e) {
13074       {
13075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13076       };
13077     } catch (Dali::DaliException e) {
13078       {
13079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13080       };
13081     } catch (...) {
13082       {
13083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13084       };
13085     }
13086   }
13087
13088   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13089   return jresult;
13090 }
13091
13092
13093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13094   unsigned int jresult ;
13095   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13096   Dali::Matrix *arg2 = 0 ;
13097   bool result;
13098
13099   arg1 = (Dali::Matrix *)jarg1;
13100   arg2 = (Dali::Matrix *)jarg2;
13101   if (!arg2) {
13102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13103     return 0;
13104   }
13105   {
13106     try {
13107       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13108     } catch (std::out_of_range& e) {
13109       {
13110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13111       };
13112     } catch (std::exception& e) {
13113       {
13114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13115       };
13116     } catch (Dali::DaliException e) {
13117       {
13118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13119       };
13120     } catch (...) {
13121       {
13122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13123       };
13124     }
13125   }
13126
13127   jresult = result;
13128   return jresult;
13129 }
13130
13131
13132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13133   unsigned int jresult ;
13134   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13135   Dali::Matrix *arg2 = 0 ;
13136   bool result;
13137
13138   arg1 = (Dali::Matrix *)jarg1;
13139   arg2 = (Dali::Matrix *)jarg2;
13140   if (!arg2) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13142     return 0;
13143   }
13144   {
13145     try {
13146       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13147     } catch (std::out_of_range& e) {
13148       {
13149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13150       };
13151     } catch (std::exception& e) {
13152       {
13153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13154       };
13155     } catch (Dali::DaliException e) {
13156       {
13157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13158       };
13159     } catch (...) {
13160       {
13161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13162       };
13163     }
13164   }
13165
13166   jresult = result;
13167   return jresult;
13168 }
13169
13170
13171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13172   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13173   Dali::Vector3 *arg2 = 0 ;
13174   Dali::Quaternion *arg3 = 0 ;
13175   Dali::Vector3 *arg4 = 0 ;
13176
13177   arg1 = (Dali::Matrix *)jarg1;
13178   arg2 = (Dali::Vector3 *)jarg2;
13179   if (!arg2) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13181     return ;
13182   }
13183   arg3 = (Dali::Quaternion *)jarg3;
13184   if (!arg3) {
13185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13186     return ;
13187   }
13188   arg4 = (Dali::Vector3 *)jarg4;
13189   if (!arg4) {
13190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13191     return ;
13192   }
13193   {
13194     try {
13195       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13196     } catch (std::out_of_range& e) {
13197       {
13198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13199       };
13200     } catch (std::exception& e) {
13201       {
13202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13203       };
13204     } catch (Dali::DaliException e) {
13205       {
13206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13207       };
13208     } catch (...) {
13209       {
13210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13211       };
13212     }
13213   }
13214
13215 }
13216
13217
13218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13219   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13220   Dali::Vector3 *arg2 = 0 ;
13221   Dali::Quaternion *arg3 = 0 ;
13222   Dali::Vector3 *arg4 = 0 ;
13223
13224   arg1 = (Dali::Matrix *)jarg1;
13225   arg2 = (Dali::Vector3 *)jarg2;
13226   if (!arg2) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13228     return ;
13229   }
13230   arg3 = (Dali::Quaternion *)jarg3;
13231   if (!arg3) {
13232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13233     return ;
13234   }
13235   arg4 = (Dali::Vector3 *)jarg4;
13236   if (!arg4) {
13237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13238     return ;
13239   }
13240   {
13241     try {
13242       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13243     } catch (std::out_of_range& e) {
13244       {
13245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13246       };
13247     } catch (std::exception& e) {
13248       {
13249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13250       };
13251     } catch (Dali::DaliException e) {
13252       {
13253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13254       };
13255     } catch (...) {
13256       {
13257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13258       };
13259     }
13260   }
13261
13262 }
13263
13264
13265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13266   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13267   Dali::Vector3 *arg2 = 0 ;
13268   Dali::Vector3 *arg3 = 0 ;
13269   Dali::Vector3 *arg4 = 0 ;
13270   Dali::Vector3 *arg5 = 0 ;
13271
13272   arg1 = (Dali::Matrix *)jarg1;
13273   arg2 = (Dali::Vector3 *)jarg2;
13274   if (!arg2) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg3 = (Dali::Vector3 *)jarg3;
13279   if (!arg3) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   arg4 = (Dali::Vector3 *)jarg4;
13284   if (!arg4) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13286     return ;
13287   }
13288   arg5 = (Dali::Vector3 *)jarg5;
13289   if (!arg5) {
13290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13291     return ;
13292   }
13293   {
13294     try {
13295       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13296     } catch (std::out_of_range& e) {
13297       {
13298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13299       };
13300     } catch (std::exception& e) {
13301       {
13302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13303       };
13304     } catch (Dali::DaliException e) {
13305       {
13306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13307       };
13308     } catch (...) {
13309       {
13310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13311       };
13312     }
13313   }
13314
13315 }
13316
13317
13318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13319   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13320   Dali::Vector3 *arg2 = 0 ;
13321   Dali::Quaternion *arg3 = 0 ;
13322   Dali::Vector3 *arg4 = 0 ;
13323
13324   arg1 = (Dali::Matrix *)jarg1;
13325   arg2 = (Dali::Vector3 *)jarg2;
13326   if (!arg2) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13328     return ;
13329   }
13330   arg3 = (Dali::Quaternion *)jarg3;
13331   if (!arg3) {
13332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13333     return ;
13334   }
13335   arg4 = (Dali::Vector3 *)jarg4;
13336   if (!arg4) {
13337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13338     return ;
13339   }
13340   {
13341     try {
13342       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13343     } catch (std::out_of_range& e) {
13344       {
13345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13346       };
13347     } catch (std::exception& e) {
13348       {
13349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13350       };
13351     } catch (Dali::DaliException e) {
13352       {
13353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13354       };
13355     } catch (...) {
13356       {
13357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13358       };
13359     }
13360   }
13361
13362 }
13363
13364
13365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13366   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13367
13368   arg1 = (Dali::Matrix *)jarg1;
13369   {
13370     try {
13371       delete arg1;
13372     } catch (std::out_of_range& e) {
13373       {
13374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13375       };
13376     } catch (std::exception& e) {
13377       {
13378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13379       };
13380     } catch (Dali::DaliException e) {
13381       {
13382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13383       };
13384     } catch (...) {
13385       {
13386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13387       };
13388     }
13389   }
13390
13391 }
13392
13393
13394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13395   void * jresult ;
13396   Dali::Matrix3 *result = 0 ;
13397
13398   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13399   jresult = (void *)result;
13400   return jresult;
13401 }
13402
13403
13404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13405   void * jresult ;
13406   Dali::Matrix3 *result = 0 ;
13407
13408   {
13409     try {
13410       result = (Dali::Matrix3 *)new Dali::Matrix3();
13411     } catch (std::out_of_range& e) {
13412       {
13413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13414       };
13415     } catch (std::exception& e) {
13416       {
13417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13418       };
13419     } catch (Dali::DaliException e) {
13420       {
13421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13422       };
13423     } catch (...) {
13424       {
13425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13426       };
13427     }
13428   }
13429
13430   jresult = (void *)result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13436   void * jresult ;
13437   Dali::Matrix3 *arg1 = 0 ;
13438   Dali::Matrix3 *result = 0 ;
13439
13440   arg1 = (Dali::Matrix3 *)jarg1;
13441   if (!arg1) {
13442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13443     return 0;
13444   }
13445   {
13446     try {
13447       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13448     } catch (std::out_of_range& e) {
13449       {
13450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13451       };
13452     } catch (std::exception& e) {
13453       {
13454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13455       };
13456     } catch (Dali::DaliException e) {
13457       {
13458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13459       };
13460     } catch (...) {
13461       {
13462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13463       };
13464     }
13465   }
13466
13467   jresult = (void *)result;
13468   return jresult;
13469 }
13470
13471
13472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13473   void * jresult ;
13474   Dali::Matrix *arg1 = 0 ;
13475   Dali::Matrix3 *result = 0 ;
13476
13477   arg1 = (Dali::Matrix *)jarg1;
13478   if (!arg1) {
13479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13480     return 0;
13481   }
13482   {
13483     try {
13484       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13485     } catch (std::out_of_range& e) {
13486       {
13487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13488       };
13489     } catch (std::exception& e) {
13490       {
13491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13492       };
13493     } catch (Dali::DaliException e) {
13494       {
13495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13496       };
13497     } catch (...) {
13498       {
13499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13500       };
13501     }
13502   }
13503
13504   jresult = (void *)result;
13505   return jresult;
13506 }
13507
13508
13509 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) {
13510   void * jresult ;
13511   float arg1 ;
13512   float arg2 ;
13513   float arg3 ;
13514   float arg4 ;
13515   float arg5 ;
13516   float arg6 ;
13517   float arg7 ;
13518   float arg8 ;
13519   float arg9 ;
13520   Dali::Matrix3 *result = 0 ;
13521
13522   arg1 = (float)jarg1;
13523   arg2 = (float)jarg2;
13524   arg3 = (float)jarg3;
13525   arg4 = (float)jarg4;
13526   arg5 = (float)jarg5;
13527   arg6 = (float)jarg6;
13528   arg7 = (float)jarg7;
13529   arg8 = (float)jarg8;
13530   arg9 = (float)jarg9;
13531   {
13532     try {
13533       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13534     } catch (std::out_of_range& e) {
13535       {
13536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13537       };
13538     } catch (std::exception& e) {
13539       {
13540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13541       };
13542     } catch (Dali::DaliException e) {
13543       {
13544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13545       };
13546     } catch (...) {
13547       {
13548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13549       };
13550     }
13551   }
13552
13553   jresult = (void *)result;
13554   return jresult;
13555 }
13556
13557
13558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13559   void * jresult ;
13560   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13561   Dali::Matrix3 *arg2 = 0 ;
13562   Dali::Matrix3 *result = 0 ;
13563
13564   arg1 = (Dali::Matrix3 *)jarg1;
13565   arg2 = (Dali::Matrix3 *)jarg2;
13566   if (!arg2) {
13567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13568     return 0;
13569   }
13570   {
13571     try {
13572       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13573     } catch (std::out_of_range& e) {
13574       {
13575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13576       };
13577     } catch (std::exception& e) {
13578       {
13579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13580       };
13581     } catch (Dali::DaliException e) {
13582       {
13583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13584       };
13585     } catch (...) {
13586       {
13587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13588       };
13589     }
13590   }
13591
13592   jresult = (void *)result;
13593   return jresult;
13594 }
13595
13596
13597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13598   void * jresult ;
13599   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13600   Dali::Matrix *arg2 = 0 ;
13601   Dali::Matrix3 *result = 0 ;
13602
13603   arg1 = (Dali::Matrix3 *)jarg1;
13604   arg2 = (Dali::Matrix *)jarg2;
13605   if (!arg2) {
13606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13607     return 0;
13608   }
13609   {
13610     try {
13611       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13612     } catch (std::out_of_range& e) {
13613       {
13614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13615       };
13616     } catch (std::exception& e) {
13617       {
13618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13619       };
13620     } catch (Dali::DaliException e) {
13621       {
13622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13623       };
13624     } catch (...) {
13625       {
13626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13627       };
13628     }
13629   }
13630
13631   jresult = (void *)result;
13632   return jresult;
13633 }
13634
13635
13636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13637   unsigned int jresult ;
13638   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13639   Dali::Matrix3 *arg2 = 0 ;
13640   bool result;
13641
13642   arg1 = (Dali::Matrix3 *)jarg1;
13643   arg2 = (Dali::Matrix3 *)jarg2;
13644   if (!arg2) {
13645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13646     return 0;
13647   }
13648   {
13649     try {
13650       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13651     } catch (std::out_of_range& e) {
13652       {
13653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13654       };
13655     } catch (std::exception& e) {
13656       {
13657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13658       };
13659     } catch (Dali::DaliException e) {
13660       {
13661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13662       };
13663     } catch (...) {
13664       {
13665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13666       };
13667     }
13668   }
13669
13670   jresult = result;
13671   return jresult;
13672 }
13673
13674
13675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13676   unsigned int jresult ;
13677   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13678   Dali::Matrix3 *arg2 = 0 ;
13679   bool result;
13680
13681   arg1 = (Dali::Matrix3 *)jarg1;
13682   arg2 = (Dali::Matrix3 *)jarg2;
13683   if (!arg2) {
13684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13685     return 0;
13686   }
13687   {
13688     try {
13689       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13690     } catch (std::out_of_range& e) {
13691       {
13692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13693       };
13694     } catch (std::exception& e) {
13695       {
13696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13697       };
13698     } catch (Dali::DaliException e) {
13699       {
13700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13701       };
13702     } catch (...) {
13703       {
13704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13705       };
13706     }
13707   }
13708
13709   jresult = result;
13710   return jresult;
13711 }
13712
13713
13714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13715   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13716
13717   arg1 = (Dali::Matrix3 *)jarg1;
13718   {
13719     try {
13720       delete arg1;
13721     } catch (std::out_of_range& e) {
13722       {
13723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13724       };
13725     } catch (std::exception& e) {
13726       {
13727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13728       };
13729     } catch (Dali::DaliException e) {
13730       {
13731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13732       };
13733     } catch (...) {
13734       {
13735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13736       };
13737     }
13738   }
13739
13740 }
13741
13742
13743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13744   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13745
13746   arg1 = (Dali::Matrix3 *)jarg1;
13747   {
13748     try {
13749       (arg1)->SetIdentity();
13750     } catch (std::out_of_range& e) {
13751       {
13752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13753       };
13754     } catch (std::exception& e) {
13755       {
13756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13757       };
13758     } catch (Dali::DaliException e) {
13759       {
13760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13761       };
13762     } catch (...) {
13763       {
13764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13765       };
13766     }
13767   }
13768
13769 }
13770
13771
13772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13773   void * jresult ;
13774   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13775   float *result = 0 ;
13776
13777   arg1 = (Dali::Matrix3 *)jarg1;
13778   {
13779     try {
13780       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13781     } catch (std::out_of_range& e) {
13782       {
13783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13784       };
13785     } catch (std::exception& e) {
13786       {
13787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (Dali::DaliException e) {
13790       {
13791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13792       };
13793     } catch (...) {
13794       {
13795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13796       };
13797     }
13798   }
13799
13800   jresult = (void *)result;
13801   return jresult;
13802 }
13803
13804
13805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13806   unsigned int jresult ;
13807   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13808   bool result;
13809
13810   arg1 = (Dali::Matrix3 *)jarg1;
13811   {
13812     try {
13813       result = (bool)(arg1)->Invert();
13814     } catch (std::out_of_range& e) {
13815       {
13816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13817       };
13818     } catch (std::exception& e) {
13819       {
13820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13821       };
13822     } catch (Dali::DaliException e) {
13823       {
13824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13825       };
13826     } catch (...) {
13827       {
13828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13829       };
13830     }
13831   }
13832
13833   jresult = result;
13834   return jresult;
13835 }
13836
13837
13838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13839   unsigned int jresult ;
13840   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13841   bool result;
13842
13843   arg1 = (Dali::Matrix3 *)jarg1;
13844   {
13845     try {
13846       result = (bool)(arg1)->Transpose();
13847     } catch (std::out_of_range& e) {
13848       {
13849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13850       };
13851     } catch (std::exception& e) {
13852       {
13853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (Dali::DaliException e) {
13856       {
13857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865
13866   jresult = result;
13867   return jresult;
13868 }
13869
13870
13871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13872   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13873   float arg2 ;
13874
13875   arg1 = (Dali::Matrix3 *)jarg1;
13876   arg2 = (float)jarg2;
13877   {
13878     try {
13879       (arg1)->Scale(arg2);
13880     } catch (std::out_of_range& e) {
13881       {
13882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13883       };
13884     } catch (std::exception& e) {
13885       {
13886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13887       };
13888     } catch (Dali::DaliException e) {
13889       {
13890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13895       };
13896     }
13897   }
13898
13899 }
13900
13901
13902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13903   float jresult ;
13904   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13905   float result;
13906
13907   arg1 = (Dali::Matrix3 *)jarg1;
13908   {
13909     try {
13910       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13911     } catch (std::out_of_range& e) {
13912       {
13913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13914       };
13915     } catch (std::exception& e) {
13916       {
13917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13918       };
13919     } catch (Dali::DaliException e) {
13920       {
13921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13922       };
13923     } catch (...) {
13924       {
13925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13926       };
13927     }
13928   }
13929
13930   jresult = result;
13931   return jresult;
13932 }
13933
13934
13935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13936   unsigned int jresult ;
13937   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13938   bool result;
13939
13940   arg1 = (Dali::Matrix3 *)jarg1;
13941   {
13942     try {
13943       result = (bool)(arg1)->ScaledInverseTranspose();
13944     } catch (std::out_of_range& e) {
13945       {
13946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13947       };
13948     } catch (std::exception& e) {
13949       {
13950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13951       };
13952     } catch (Dali::DaliException e) {
13953       {
13954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13955       };
13956     } catch (...) {
13957       {
13958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13959       };
13960     }
13961   }
13962
13963   jresult = result;
13964   return jresult;
13965 }
13966
13967
13968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13969   Dali::Matrix3 *arg1 = 0 ;
13970   Dali::Matrix3 *arg2 = 0 ;
13971   Dali::Matrix3 *arg3 = 0 ;
13972
13973   arg1 = (Dali::Matrix3 *)jarg1;
13974   if (!arg1) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13976     return ;
13977   }
13978   arg2 = (Dali::Matrix3 *)jarg2;
13979   if (!arg2) {
13980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13981     return ;
13982   }
13983   arg3 = (Dali::Matrix3 *)jarg3;
13984   if (!arg3) {
13985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13986     return ;
13987   }
13988   {
13989     try {
13990       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13991     } catch (std::out_of_range& e) {
13992       {
13993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13994       };
13995     } catch (std::exception& e) {
13996       {
13997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13998       };
13999     } catch (Dali::DaliException e) {
14000       {
14001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14002       };
14003     } catch (...) {
14004       {
14005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14006       };
14007     }
14008   }
14009
14010 }
14011
14012
14013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14014   float jresult ;
14015   float arg1 ;
14016   float arg2 ;
14017   float result;
14018
14019   arg1 = (float)jarg1;
14020   arg2 = (float)jarg2;
14021   {
14022     try {
14023       result = (float)Dali::Random::Range(arg1,arg2);
14024     } catch (std::out_of_range& e) {
14025       {
14026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (std::exception& e) {
14029       {
14030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14031       };
14032     } catch (Dali::DaliException e) {
14033       {
14034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14035       };
14036     } catch (...) {
14037       {
14038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14039       };
14040     }
14041   }
14042
14043   jresult = result;
14044   return jresult;
14045 }
14046
14047
14048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14049   void * jresult ;
14050   Dali::Vector4 result;
14051
14052   {
14053     try {
14054       result = Dali::Random::Axis();
14055     } catch (std::out_of_range& e) {
14056       {
14057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14058       };
14059     } catch (std::exception& e) {
14060       {
14061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14062       };
14063     } catch (Dali::DaliException e) {
14064       {
14065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14066       };
14067     } catch (...) {
14068       {
14069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14070       };
14071     }
14072   }
14073
14074   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14075   return jresult;
14076 }
14077
14078
14079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14080   void * jresult ;
14081   Dali::AngleAxis *result = 0 ;
14082
14083   {
14084     try {
14085       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14086     } catch (std::out_of_range& e) {
14087       {
14088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (std::exception& e) {
14091       {
14092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14093       };
14094     } catch (Dali::DaliException e) {
14095       {
14096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14097       };
14098     } catch (...) {
14099       {
14100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14101       };
14102     }
14103   }
14104
14105   jresult = (void *)result;
14106   return jresult;
14107 }
14108
14109
14110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14111   void * jresult ;
14112   Dali::Radian arg1 ;
14113   Dali::Vector3 *arg2 = 0 ;
14114   Dali::Radian *argp1 ;
14115   Dali::AngleAxis *result = 0 ;
14116
14117   argp1 = (Dali::Radian *)jarg1;
14118   if (!argp1) {
14119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14120     return 0;
14121   }
14122   arg1 = *argp1;
14123   arg2 = (Dali::Vector3 *)jarg2;
14124   if (!arg2) {
14125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14126     return 0;
14127   }
14128   {
14129     try {
14130       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14131     } catch (std::out_of_range& e) {
14132       {
14133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14134       };
14135     } catch (std::exception& e) {
14136       {
14137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14138       };
14139     } catch (Dali::DaliException e) {
14140       {
14141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14142       };
14143     } catch (...) {
14144       {
14145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14146       };
14147     }
14148   }
14149
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14156   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14157   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14158
14159   arg1 = (Dali::AngleAxis *)jarg1;
14160   arg2 = (Dali::Radian *)jarg2;
14161   if (arg1) (arg1)->angle = *arg2;
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14166   void * jresult ;
14167   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14168   Dali::Radian *result = 0 ;
14169
14170   arg1 = (Dali::AngleAxis *)jarg1;
14171   result = (Dali::Radian *)& ((arg1)->angle);
14172   jresult = (void *)result;
14173   return jresult;
14174 }
14175
14176
14177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14178   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14179   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14180
14181   arg1 = (Dali::AngleAxis *)jarg1;
14182   arg2 = (Dali::Vector3 *)jarg2;
14183   if (arg1) (arg1)->axis = *arg2;
14184 }
14185
14186
14187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14188   void * jresult ;
14189   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14190   Dali::Vector3 *result = 0 ;
14191
14192   arg1 = (Dali::AngleAxis *)jarg1;
14193   result = (Dali::Vector3 *)& ((arg1)->axis);
14194   jresult = (void *)result;
14195   return jresult;
14196 }
14197
14198
14199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14200   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14201
14202   arg1 = (Dali::AngleAxis *)jarg1;
14203   {
14204     try {
14205       delete arg1;
14206     } catch (std::out_of_range& e) {
14207       {
14208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14209       };
14210     } catch (std::exception& e) {
14211       {
14212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14213       };
14214     } catch (Dali::DaliException e) {
14215       {
14216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14217       };
14218     } catch (...) {
14219       {
14220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14221       };
14222     }
14223   }
14224
14225 }
14226
14227
14228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14229   unsigned int jresult ;
14230   Dali::AngleAxis *arg1 = 0 ;
14231   Dali::AngleAxis *arg2 = 0 ;
14232   bool result;
14233
14234   arg1 = (Dali::AngleAxis *)jarg1;
14235   if (!arg1) {
14236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14237     return 0;
14238   }
14239   arg2 = (Dali::AngleAxis *)jarg2;
14240   if (!arg2) {
14241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14242     return 0;
14243   }
14244   {
14245     try {
14246       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14247     } catch (std::out_of_range& e) {
14248       {
14249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14250       };
14251     } catch (std::exception& e) {
14252       {
14253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14254       };
14255     } catch (Dali::DaliException e) {
14256       {
14257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14258       };
14259     } catch (...) {
14260       {
14261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14262       };
14263     }
14264   }
14265
14266   jresult = result;
14267   return jresult;
14268 }
14269
14270
14271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14272   unsigned int jresult ;
14273   unsigned int arg1 ;
14274   unsigned int result;
14275
14276   arg1 = (unsigned int)jarg1;
14277   {
14278     try {
14279       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14280     } catch (std::out_of_range& e) {
14281       {
14282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (std::exception& e) {
14285       {
14286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14287       };
14288     } catch (Dali::DaliException e) {
14289       {
14290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14291       };
14292     } catch (...) {
14293       {
14294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14295       };
14296     }
14297   }
14298
14299   jresult = result;
14300   return jresult;
14301 }
14302
14303
14304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14305   unsigned int jresult ;
14306   unsigned int arg1 ;
14307   bool result;
14308
14309   arg1 = (unsigned int)jarg1;
14310   {
14311     try {
14312       result = (bool)Dali::IsPowerOfTwo(arg1);
14313     } catch (std::out_of_range& e) {
14314       {
14315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14316       };
14317     } catch (std::exception& e) {
14318       {
14319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14320       };
14321     } catch (Dali::DaliException e) {
14322       {
14323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14324       };
14325     } catch (...) {
14326       {
14327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14328       };
14329     }
14330   }
14331
14332   jresult = result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14338   float jresult ;
14339   float arg1 ;
14340   float arg2 ;
14341   float result;
14342
14343   arg1 = (float)jarg1;
14344   arg2 = (float)jarg2;
14345   {
14346     try {
14347       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (Dali::DaliException e) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14359       };
14360     } catch (...) {
14361       {
14362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14363       };
14364     }
14365   }
14366
14367   jresult = result;
14368   return jresult;
14369 }
14370
14371
14372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14373   unsigned int jresult ;
14374   float arg1 ;
14375   bool result;
14376
14377   arg1 = (float)jarg1;
14378   {
14379     try {
14380       result = (bool)Dali::EqualsZero(arg1);
14381     } catch (std::out_of_range& e) {
14382       {
14383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14384       };
14385     } catch (std::exception& e) {
14386       {
14387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (Dali::DaliException e) {
14390       {
14391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399
14400   jresult = result;
14401   return jresult;
14402 }
14403
14404
14405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14406   unsigned int jresult ;
14407   float arg1 ;
14408   float arg2 ;
14409   bool result;
14410
14411   arg1 = (float)jarg1;
14412   arg2 = (float)jarg2;
14413   {
14414     try {
14415       result = (bool)Dali::Equals(arg1,arg2);
14416     } catch (std::out_of_range& e) {
14417       {
14418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14419       };
14420     } catch (std::exception& e) {
14421       {
14422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14423       };
14424     } catch (Dali::DaliException e) {
14425       {
14426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14427       };
14428     } catch (...) {
14429       {
14430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14431       };
14432     }
14433   }
14434
14435   jresult = result;
14436   return jresult;
14437 }
14438
14439
14440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14441   unsigned int jresult ;
14442   float arg1 ;
14443   float arg2 ;
14444   float arg3 ;
14445   bool result;
14446
14447   arg1 = (float)jarg1;
14448   arg2 = (float)jarg2;
14449   arg3 = (float)jarg3;
14450   {
14451     try {
14452       result = (bool)Dali::Equals(arg1,arg2,arg3);
14453     } catch (std::out_of_range& e) {
14454       {
14455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14456       };
14457     } catch (std::exception& e) {
14458       {
14459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14460       };
14461     } catch (Dali::DaliException e) {
14462       {
14463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14464       };
14465     } catch (...) {
14466       {
14467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14468       };
14469     }
14470   }
14471
14472   jresult = result;
14473   return jresult;
14474 }
14475
14476
14477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14478   float jresult ;
14479   float arg1 ;
14480   int arg2 ;
14481   float result;
14482
14483   arg1 = (float)jarg1;
14484   arg2 = (int)jarg2;
14485   {
14486     try {
14487       result = (float)Dali::Round(arg1,arg2);
14488     } catch (std::out_of_range& e) {
14489       {
14490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14491       };
14492     } catch (std::exception& e) {
14493       {
14494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14495       };
14496     } catch (Dali::DaliException e) {
14497       {
14498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14499       };
14500     } catch (...) {
14501       {
14502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14503       };
14504     }
14505   }
14506
14507   jresult = result;
14508   return jresult;
14509 }
14510
14511
14512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14513   float jresult ;
14514   float arg1 ;
14515   float arg2 ;
14516   float arg3 ;
14517   float result;
14518
14519   arg1 = (float)jarg1;
14520   arg2 = (float)jarg2;
14521   arg3 = (float)jarg3;
14522   {
14523     try {
14524       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14525     } catch (std::out_of_range& e) {
14526       {
14527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14528       };
14529     } catch (std::exception& e) {
14530       {
14531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14532       };
14533     } catch (Dali::DaliException e) {
14534       {
14535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14536       };
14537     } catch (...) {
14538       {
14539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14540       };
14541     }
14542   }
14543
14544   jresult = result;
14545   return jresult;
14546 }
14547
14548
14549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14550   float jresult ;
14551   float arg1 ;
14552   float arg2 ;
14553   float arg3 ;
14554   float arg4 ;
14555   float result;
14556
14557   arg1 = (float)jarg1;
14558   arg2 = (float)jarg2;
14559   arg3 = (float)jarg3;
14560   arg4 = (float)jarg4;
14561   {
14562     try {
14563       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14564     } catch (std::out_of_range& e) {
14565       {
14566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14567       };
14568     } catch (std::exception& e) {
14569       {
14570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14571       };
14572     } catch (Dali::DaliException e) {
14573       {
14574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14575       };
14576     } catch (...) {
14577       {
14578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14579       };
14580     }
14581   }
14582
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14589   int jresult ;
14590   int result;
14591
14592   result = (int)(int)Dali::Property::INVALID_INDEX;
14593   jresult = result;
14594   return jresult;
14595 }
14596
14597
14598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14599   int jresult ;
14600   int result;
14601
14602   result = (int)(int)Dali::Property::INVALID_KEY;
14603   jresult = result;
14604   return jresult;
14605 }
14606
14607
14608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14609   int jresult ;
14610   int result;
14611
14612   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14613   jresult = result;
14614   return jresult;
14615 }
14616
14617
14618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14619   void * jresult ;
14620   Dali::Handle *arg1 = 0 ;
14621   Dali::Property::Index arg2 ;
14622   Dali::Property *result = 0 ;
14623
14624   arg1 = (Dali::Handle *)jarg1;
14625   if (!arg1) {
14626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14627     return 0;
14628   }
14629   arg2 = (Dali::Property::Index)jarg2;
14630   {
14631     try {
14632       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14633     } catch (std::out_of_range& e) {
14634       {
14635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14636       };
14637     } catch (std::exception& e) {
14638       {
14639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14640       };
14641     } catch (Dali::DaliException e) {
14642       {
14643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14644       };
14645     } catch (...) {
14646       {
14647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14648       };
14649     }
14650   }
14651
14652   jresult = (void *)result;
14653   return jresult;
14654 }
14655
14656
14657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14658   void * jresult ;
14659   Dali::Handle *arg1 = 0 ;
14660   Dali::Property::Index arg2 ;
14661   int arg3 ;
14662   Dali::Property *result = 0 ;
14663
14664   arg1 = (Dali::Handle *)jarg1;
14665   if (!arg1) {
14666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14667     return 0;
14668   }
14669   arg2 = (Dali::Property::Index)jarg2;
14670   arg3 = (int)jarg3;
14671   {
14672     try {
14673       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14674     } catch (std::out_of_range& e) {
14675       {
14676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (std::exception& e) {
14679       {
14680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14681       };
14682     } catch (Dali::DaliException e) {
14683       {
14684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14685       };
14686     } catch (...) {
14687       {
14688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14689       };
14690     }
14691   }
14692
14693   jresult = (void *)result;
14694   return jresult;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14699   void * jresult ;
14700   Dali::Handle *arg1 = 0 ;
14701   std::string *arg2 = 0 ;
14702   Dali::Property *result = 0 ;
14703
14704   arg1 = (Dali::Handle *)jarg1;
14705   if (!arg1) {
14706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14707     return 0;
14708   }
14709   if (!jarg2) {
14710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14711     return 0;
14712   }
14713   std::string arg2_str(jarg2);
14714   arg2 = &arg2_str;
14715   {
14716     try {
14717       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14718     } catch (std::out_of_range& e) {
14719       {
14720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14721       };
14722     } catch (std::exception& e) {
14723       {
14724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14725       };
14726     } catch (Dali::DaliException e) {
14727       {
14728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14729       };
14730     } catch (...) {
14731       {
14732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14733       };
14734     }
14735   }
14736
14737   jresult = (void *)result;
14738
14739   //argout typemap for const std::string&
14740
14741   return jresult;
14742 }
14743
14744
14745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14746   void * jresult ;
14747   Dali::Handle *arg1 = 0 ;
14748   std::string *arg2 = 0 ;
14749   int arg3 ;
14750   Dali::Property *result = 0 ;
14751
14752   arg1 = (Dali::Handle *)jarg1;
14753   if (!arg1) {
14754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14755     return 0;
14756   }
14757   if (!jarg2) {
14758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14759     return 0;
14760   }
14761   std::string arg2_str(jarg2);
14762   arg2 = &arg2_str;
14763   arg3 = (int)jarg3;
14764   {
14765     try {
14766       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14767     } catch (std::out_of_range& e) {
14768       {
14769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (std::exception& e) {
14772       {
14773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14774       };
14775     } catch (Dali::DaliException e) {
14776       {
14777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14778       };
14779     } catch (...) {
14780       {
14781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14782       };
14783     }
14784   }
14785
14786   jresult = (void *)result;
14787
14788   //argout typemap for const std::string&
14789
14790   return jresult;
14791 }
14792
14793
14794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14795   Dali::Property *arg1 = (Dali::Property *) 0 ;
14796
14797   arg1 = (Dali::Property *)jarg1;
14798   {
14799     try {
14800       delete arg1;
14801     } catch (std::out_of_range& e) {
14802       {
14803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14804       };
14805     } catch (std::exception& e) {
14806       {
14807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14808       };
14809     } catch (Dali::DaliException e) {
14810       {
14811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14812       };
14813     } catch (...) {
14814       {
14815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14816       };
14817     }
14818   }
14819
14820 }
14821
14822
14823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14824   Dali::Property *arg1 = (Dali::Property *) 0 ;
14825   Dali::Handle *arg2 = 0 ;
14826
14827   arg1 = (Dali::Property *)jarg1;
14828   arg2 = (Dali::Handle *)jarg2;
14829   if (!arg2) {
14830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14831     return ;
14832   }
14833   if (arg1) (arg1)->object = *arg2;
14834 }
14835
14836
14837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14838   void * jresult ;
14839   Dali::Property *arg1 = (Dali::Property *) 0 ;
14840   Dali::Handle *result = 0 ;
14841
14842   arg1 = (Dali::Property *)jarg1;
14843   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14844   jresult = (void *)result;
14845   return jresult;
14846 }
14847
14848
14849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14850   Dali::Property *arg1 = (Dali::Property *) 0 ;
14851   Dali::Property::Index arg2 ;
14852
14853   arg1 = (Dali::Property *)jarg1;
14854   arg2 = (Dali::Property::Index)jarg2;
14855   if (arg1) (arg1)->propertyIndex = arg2;
14856 }
14857
14858
14859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14860   int jresult ;
14861   Dali::Property *arg1 = (Dali::Property *) 0 ;
14862   Dali::Property::Index result;
14863
14864   arg1 = (Dali::Property *)jarg1;
14865   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14866   jresult = result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14872   Dali::Property *arg1 = (Dali::Property *) 0 ;
14873   int arg2 ;
14874
14875   arg1 = (Dali::Property *)jarg1;
14876   arg2 = (int)jarg2;
14877   if (arg1) (arg1)->componentIndex = arg2;
14878 }
14879
14880
14881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14882   int jresult ;
14883   Dali::Property *arg1 = (Dali::Property *) 0 ;
14884   int result;
14885
14886   arg1 = (Dali::Property *)jarg1;
14887   result = (int) ((arg1)->componentIndex);
14888   jresult = result;
14889   return jresult;
14890 }
14891
14892
14893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14894   void * jresult ;
14895   Dali::Property::Array *result = 0 ;
14896
14897   {
14898     try {
14899       result = (Dali::Property::Array *)new Dali::Property::Array();
14900     } catch (std::out_of_range& e) {
14901       {
14902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14903       };
14904     } catch (std::exception& e) {
14905       {
14906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14907       };
14908     } catch (Dali::DaliException e) {
14909       {
14910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14911       };
14912     } catch (...) {
14913       {
14914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14915       };
14916     }
14917   }
14918
14919   jresult = (void *)result;
14920   return jresult;
14921 }
14922
14923
14924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14925   void * jresult ;
14926   Dali::Property::Array *arg1 = 0 ;
14927   Dali::Property::Array *result = 0 ;
14928
14929   arg1 = (Dali::Property::Array *)jarg1;
14930   if (!arg1) {
14931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14932     return 0;
14933   }
14934   {
14935     try {
14936       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14937     } catch (std::out_of_range& e) {
14938       {
14939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14940       };
14941     } catch (std::exception& e) {
14942       {
14943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14944       };
14945     } catch (Dali::DaliException e) {
14946       {
14947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14948       };
14949     } catch (...) {
14950       {
14951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14952       };
14953     }
14954   }
14955
14956   jresult = (void *)result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14962   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14963
14964   arg1 = (Dali::Property::Array *)jarg1;
14965   {
14966     try {
14967       delete arg1;
14968     } catch (std::out_of_range& e) {
14969       {
14970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14971       };
14972     } catch (std::exception& e) {
14973       {
14974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14975       };
14976     } catch (Dali::DaliException e) {
14977       {
14978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14979       };
14980     } catch (...) {
14981       {
14982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14983       };
14984     }
14985   }
14986
14987 }
14988
14989
14990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14991   unsigned long jresult ;
14992   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14993   Dali::Property::Array::SizeType result;
14994
14995   arg1 = (Dali::Property::Array *)jarg1;
14996   {
14997     try {
14998       result = ((Dali::Property::Array const *)arg1)->Size();
14999     } catch (std::out_of_range& e) {
15000       {
15001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15002       };
15003     } catch (std::exception& e) {
15004       {
15005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15006       };
15007     } catch (Dali::DaliException e) {
15008       {
15009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15010       };
15011     } catch (...) {
15012       {
15013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15014       };
15015     }
15016   }
15017
15018   jresult = (unsigned long)result;
15019   return jresult;
15020 }
15021
15022
15023 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15024   unsigned long jresult ;
15025   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15026   Dali::Property::Array::SizeType result;
15027
15028   arg1 = (Dali::Property::Array *)jarg1;
15029   {
15030     try {
15031       result = ((Dali::Property::Array const *)arg1)->Count();
15032     } catch (std::out_of_range& e) {
15033       {
15034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15035       };
15036     } catch (std::exception& e) {
15037       {
15038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (Dali::DaliException e) {
15041       {
15042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15043       };
15044     } catch (...) {
15045       {
15046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15047       };
15048     }
15049   }
15050
15051   jresult = (unsigned long)result;
15052   return jresult;
15053 }
15054
15055
15056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15057   unsigned int jresult ;
15058   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15059   bool result;
15060
15061   arg1 = (Dali::Property::Array *)jarg1;
15062   {
15063     try {
15064       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15065     } catch (std::out_of_range& e) {
15066       {
15067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (std::exception& e) {
15070       {
15071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15072       };
15073     } catch (Dali::DaliException e) {
15074       {
15075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15076       };
15077     } catch (...) {
15078       {
15079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15080       };
15081     }
15082   }
15083
15084   jresult = result;
15085   return jresult;
15086 }
15087
15088
15089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15090   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   {
15094     try {
15095       (arg1)->Clear();
15096     } catch (std::out_of_range& e) {
15097       {
15098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15099       };
15100     } catch (std::exception& e) {
15101       {
15102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15103       };
15104     } catch (Dali::DaliException e) {
15105       {
15106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15111       };
15112     }
15113   }
15114
15115 }
15116
15117
15118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15119   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15120   Dali::Property::Array::SizeType arg2 ;
15121
15122   arg1 = (Dali::Property::Array *)jarg1;
15123   arg2 = (Dali::Property::Array::SizeType)jarg2;
15124   {
15125     try {
15126       (arg1)->Reserve(arg2);
15127     } catch (std::out_of_range& e) {
15128       {
15129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15130       };
15131     } catch (std::exception& e) {
15132       {
15133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15134       };
15135     } catch (Dali::DaliException e) {
15136       {
15137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15142       };
15143     }
15144   }
15145
15146 }
15147
15148
15149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15150   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15151   Dali::Property::Array::SizeType arg2 ;
15152
15153   arg1 = (Dali::Property::Array *)jarg1;
15154   arg2 = (Dali::Property::Array::SizeType)jarg2;
15155   {
15156     try {
15157       (arg1)->Resize(arg2);
15158     } catch (std::out_of_range& e) {
15159       {
15160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15161       };
15162     } catch (std::exception& e) {
15163       {
15164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15165       };
15166     } catch (Dali::DaliException e) {
15167       {
15168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15169       };
15170     } catch (...) {
15171       {
15172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15173       };
15174     }
15175   }
15176
15177 }
15178
15179
15180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15181   unsigned long jresult ;
15182   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15183   Dali::Property::Array::SizeType result;
15184
15185   arg1 = (Dali::Property::Array *)jarg1;
15186   {
15187     try {
15188       result = (arg1)->Capacity();
15189     } catch (std::out_of_range& e) {
15190       {
15191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15192       };
15193     } catch (std::exception& e) {
15194       {
15195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15196       };
15197     } catch (Dali::DaliException e) {
15198       {
15199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15200       };
15201     } catch (...) {
15202       {
15203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15204       };
15205     }
15206   }
15207
15208   jresult = (unsigned long)result;
15209   return jresult;
15210 }
15211
15212
15213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15214   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15215   Dali::Property::Value *arg2 = 0 ;
15216
15217   arg1 = (Dali::Property::Array *)jarg1;
15218   arg2 = (Dali::Property::Value *)jarg2;
15219   if (!arg2) {
15220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15221     return ;
15222   }
15223   {
15224     try {
15225       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15226     } catch (std::out_of_range& e) {
15227       {
15228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15229       };
15230     } catch (std::exception& e) {
15231       {
15232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15233       };
15234     } catch (Dali::DaliException e) {
15235       {
15236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15237       };
15238     } catch (...) {
15239       {
15240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15241       };
15242     }
15243   }
15244
15245 }
15246
15247
15248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15249   void * jresult ;
15250   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15251   Dali::Property::Value *arg2 = 0 ;
15252   Dali::Property::Array *result = 0 ;
15253
15254   arg1 = (Dali::Property::Array *)jarg1;
15255   arg2 = (Dali::Property::Value *)jarg2;
15256   if (!arg2) {
15257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15258     return 0;
15259   }
15260   {
15261     try {
15262       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15263     } catch (std::out_of_range& e) {
15264       {
15265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15266       };
15267     } catch (std::exception& e) {
15268       {
15269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15270       };
15271     } catch (Dali::DaliException e) {
15272       {
15273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15274       };
15275     } catch (...) {
15276       {
15277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15278       };
15279     }
15280   }
15281
15282   jresult = (void *)result;
15283   return jresult;
15284 }
15285
15286
15287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15288   void * jresult ;
15289   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15290   Dali::Property::Array::SizeType arg2 ;
15291   Dali::Property::Value *result = 0 ;
15292
15293   arg1 = (Dali::Property::Array *)jarg1;
15294   arg2 = (Dali::Property::Array::SizeType)jarg2;
15295   {
15296     try {
15297       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15298     } catch (std::out_of_range& e) {
15299       {
15300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15301       };
15302     } catch (std::exception& e) {
15303       {
15304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15305       };
15306     } catch (Dali::DaliException e) {
15307       {
15308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15309       };
15310     } catch (...) {
15311       {
15312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15313       };
15314     }
15315   }
15316
15317   jresult = (void *)result;
15318   return jresult;
15319 }
15320
15321
15322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15323   void * jresult ;
15324   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15325   Dali::Property::Array::SizeType arg2 ;
15326   Dali::Property::Value *result = 0 ;
15327
15328   arg1 = (Dali::Property::Array *)jarg1;
15329   arg2 = (Dali::Property::Array::SizeType)jarg2;
15330   {
15331     try {
15332       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15333     } catch (std::out_of_range& e) {
15334       {
15335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15336       };
15337     } catch (std::exception& e) {
15338       {
15339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15340       };
15341     } catch (Dali::DaliException e) {
15342       {
15343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15344       };
15345     } catch (...) {
15346       {
15347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15348       };
15349     }
15350   }
15351
15352   jresult = (void *)result;
15353   return jresult;
15354 }
15355
15356
15357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15358   void * jresult ;
15359   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15360   Dali::Property::Array *arg2 = 0 ;
15361   Dali::Property::Array *result = 0 ;
15362
15363   arg1 = (Dali::Property::Array *)jarg1;
15364   arg2 = (Dali::Property::Array *)jarg2;
15365   if (!arg2) {
15366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15367     return 0;
15368   }
15369   {
15370     try {
15371       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15372     } catch (std::out_of_range& e) {
15373       {
15374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15375       };
15376     } catch (std::exception& e) {
15377       {
15378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15379       };
15380     } catch (Dali::DaliException e) {
15381       {
15382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15383       };
15384     } catch (...) {
15385       {
15386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15387       };
15388     }
15389   }
15390
15391   jresult = (void *)result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15397   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15398   enum Dali::Property::Key::Type arg2 ;
15399
15400   arg1 = (Dali::Property::Key *)jarg1;
15401   arg2 = (enum Dali::Property::Key::Type)jarg2;
15402   if (arg1) (arg1)->type = arg2;
15403 }
15404
15405
15406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15407   int jresult ;
15408   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15409   enum Dali::Property::Key::Type result;
15410
15411   arg1 = (Dali::Property::Key *)jarg1;
15412   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15413   jresult = (int)result;
15414   return jresult;
15415 }
15416
15417
15418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15419   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15420   Dali::Property::Index arg2 ;
15421
15422   arg1 = (Dali::Property::Key *)jarg1;
15423   arg2 = (Dali::Property::Index)jarg2;
15424   if (arg1) (arg1)->indexKey = arg2;
15425 }
15426
15427
15428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15429   int jresult ;
15430   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15431   Dali::Property::Index result;
15432
15433   arg1 = (Dali::Property::Key *)jarg1;
15434   result = (Dali::Property::Index) ((arg1)->indexKey);
15435   jresult = result;
15436   return jresult;
15437 }
15438
15439
15440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15441   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15442   std::string *arg2 = 0 ;
15443
15444   arg1 = (Dali::Property::Key *)jarg1;
15445   if (!jarg2) {
15446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15447     return ;
15448   }
15449   std::string arg2_str(jarg2);
15450   arg2 = &arg2_str;
15451   if (arg1) (arg1)->stringKey = *arg2;
15452
15453   //argout typemap for const std::string&
15454
15455 }
15456
15457
15458 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15459   char * jresult ;
15460   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15461   std::string *result = 0 ;
15462
15463   arg1 = (Dali::Property::Key *)jarg1;
15464   result = (std::string *) & ((arg1)->stringKey);
15465   jresult = SWIG_csharp_string_callback(result->c_str());
15466   return jresult;
15467 }
15468
15469
15470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15471   void * jresult ;
15472   std::string *arg1 = 0 ;
15473   Dali::Property::Key *result = 0 ;
15474
15475   if (!jarg1) {
15476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15477     return 0;
15478   }
15479   std::string arg1_str(jarg1);
15480   arg1 = &arg1_str;
15481   {
15482     try {
15483       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15484     } catch (std::out_of_range& e) {
15485       {
15486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15487       };
15488     } catch (std::exception& e) {
15489       {
15490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15491       };
15492     } catch (Dali::DaliException e) {
15493       {
15494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15495       };
15496     } catch (...) {
15497       {
15498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15499       };
15500     }
15501   }
15502
15503   jresult = (void *)result;
15504
15505   //argout typemap for const std::string&
15506
15507   return jresult;
15508 }
15509
15510
15511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15512   void * jresult ;
15513   Dali::Property::Index arg1 ;
15514   Dali::Property::Key *result = 0 ;
15515
15516   arg1 = (Dali::Property::Index)jarg1;
15517   {
15518     try {
15519       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15520     } catch (std::out_of_range& e) {
15521       {
15522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (std::exception& e) {
15525       {
15526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15527       };
15528     } catch (Dali::DaliException e) {
15529       {
15530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15531       };
15532     } catch (...) {
15533       {
15534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15535       };
15536     }
15537   }
15538
15539   jresult = (void *)result;
15540   return jresult;
15541 }
15542
15543
15544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15545   unsigned int jresult ;
15546   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15547   std::string *arg2 = 0 ;
15548   bool result;
15549
15550   arg1 = (Dali::Property::Key *)jarg1;
15551   if (!jarg2) {
15552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15553     return 0;
15554   }
15555   std::string arg2_str(jarg2);
15556   arg2 = &arg2_str;
15557   {
15558     try {
15559       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15560     } catch (std::out_of_range& e) {
15561       {
15562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15563       };
15564     } catch (std::exception& e) {
15565       {
15566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15567       };
15568     } catch (Dali::DaliException e) {
15569       {
15570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15571       };
15572     } catch (...) {
15573       {
15574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15575       };
15576     }
15577   }
15578
15579   jresult = result;
15580
15581   //argout typemap for const std::string&
15582
15583   return jresult;
15584 }
15585
15586
15587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15588   unsigned int jresult ;
15589   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15590   Dali::Property::Index arg2 ;
15591   bool result;
15592
15593   arg1 = (Dali::Property::Key *)jarg1;
15594   arg2 = (Dali::Property::Index)jarg2;
15595   {
15596     try {
15597       result = (bool)(arg1)->operator ==(arg2);
15598     } catch (std::out_of_range& e) {
15599       {
15600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15601       };
15602     } catch (std::exception& e) {
15603       {
15604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15605       };
15606     } catch (Dali::DaliException e) {
15607       {
15608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15609       };
15610     } catch (...) {
15611       {
15612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15613       };
15614     }
15615   }
15616
15617   jresult = result;
15618   return jresult;
15619 }
15620
15621
15622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15623   unsigned int jresult ;
15624   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15625   Dali::Property::Key *arg2 = 0 ;
15626   bool result;
15627
15628   arg1 = (Dali::Property::Key *)jarg1;
15629   arg2 = (Dali::Property::Key *)jarg2;
15630   if (!arg2) {
15631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15632     return 0;
15633   }
15634   {
15635     try {
15636       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15637     } catch (std::out_of_range& e) {
15638       {
15639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (std::exception& e) {
15642       {
15643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15644       };
15645     } catch (Dali::DaliException e) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15648       };
15649     } catch (...) {
15650       {
15651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15652       };
15653     }
15654   }
15655
15656   jresult = result;
15657   return jresult;
15658 }
15659
15660
15661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15662   unsigned int jresult ;
15663   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15664   std::string *arg2 = 0 ;
15665   bool result;
15666
15667   arg1 = (Dali::Property::Key *)jarg1;
15668   if (!jarg2) {
15669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15670     return 0;
15671   }
15672   std::string arg2_str(jarg2);
15673   arg2 = &arg2_str;
15674   {
15675     try {
15676       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15677     } catch (std::out_of_range& e) {
15678       {
15679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (std::exception& e) {
15682       {
15683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15684       };
15685     } catch (Dali::DaliException e) {
15686       {
15687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15688       };
15689     } catch (...) {
15690       {
15691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15692       };
15693     }
15694   }
15695
15696   jresult = result;
15697
15698   //argout typemap for const std::string&
15699
15700   return jresult;
15701 }
15702
15703
15704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15705   unsigned int jresult ;
15706   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15707   Dali::Property::Index arg2 ;
15708   bool result;
15709
15710   arg1 = (Dali::Property::Key *)jarg1;
15711   arg2 = (Dali::Property::Index)jarg2;
15712   {
15713     try {
15714       result = (bool)(arg1)->operator !=(arg2);
15715     } catch (std::out_of_range& e) {
15716       {
15717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15718       };
15719     } catch (std::exception& e) {
15720       {
15721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15722       };
15723     } catch (Dali::DaliException e) {
15724       {
15725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15726       };
15727     } catch (...) {
15728       {
15729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15730       };
15731     }
15732   }
15733
15734   jresult = result;
15735   return jresult;
15736 }
15737
15738
15739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15740   unsigned int jresult ;
15741   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15742   Dali::Property::Key *arg2 = 0 ;
15743   bool result;
15744
15745   arg1 = (Dali::Property::Key *)jarg1;
15746   arg2 = (Dali::Property::Key *)jarg2;
15747   if (!arg2) {
15748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15749     return 0;
15750   }
15751   {
15752     try {
15753       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15754     } catch (std::out_of_range& e) {
15755       {
15756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15757       };
15758     } catch (std::exception& e) {
15759       {
15760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15761       };
15762     } catch (Dali::DaliException e) {
15763       {
15764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15765       };
15766     } catch (...) {
15767       {
15768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15769       };
15770     }
15771   }
15772
15773   jresult = result;
15774   return jresult;
15775 }
15776
15777
15778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15779   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15780
15781   arg1 = (Dali::Property::Key *)jarg1;
15782   {
15783     try {
15784       delete arg1;
15785     } catch (std::out_of_range& e) {
15786       {
15787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15788       };
15789     } catch (std::exception& e) {
15790       {
15791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15792       };
15793     } catch (Dali::DaliException e) {
15794       {
15795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15796       };
15797     } catch (...) {
15798       {
15799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15800       };
15801     }
15802   }
15803
15804 }
15805
15806
15807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15808   void * jresult ;
15809   Dali::Property::Map *result = 0 ;
15810
15811   {
15812     try {
15813       result = (Dali::Property::Map *)new Dali::Property::Map();
15814     } catch (std::out_of_range& e) {
15815       {
15816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15817       };
15818     } catch (std::exception& e) {
15819       {
15820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15821       };
15822     } catch (Dali::DaliException e) {
15823       {
15824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15825       };
15826     } catch (...) {
15827       {
15828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15829       };
15830     }
15831   }
15832
15833   jresult = (void *)result;
15834   return jresult;
15835 }
15836
15837
15838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15839   void * jresult ;
15840   Dali::Property::Map *arg1 = 0 ;
15841   Dali::Property::Map *result = 0 ;
15842
15843   arg1 = (Dali::Property::Map *)jarg1;
15844   if (!arg1) {
15845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15846     return 0;
15847   }
15848   {
15849     try {
15850       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15851     } catch (std::out_of_range& e) {
15852       {
15853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (std::exception& e) {
15856       {
15857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15858       };
15859     } catch (Dali::DaliException e) {
15860       {
15861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15862       };
15863     } catch (...) {
15864       {
15865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15866       };
15867     }
15868   }
15869
15870   jresult = (void *)result;
15871   return jresult;
15872 }
15873
15874
15875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15876   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15877
15878   arg1 = (Dali::Property::Map *)jarg1;
15879   {
15880     try {
15881       delete arg1;
15882     } catch (std::out_of_range& e) {
15883       {
15884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15885       };
15886     } catch (std::exception& e) {
15887       {
15888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15889       };
15890     } catch (Dali::DaliException e) {
15891       {
15892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15893       };
15894     } catch (...) {
15895       {
15896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15897       };
15898     }
15899   }
15900
15901 }
15902
15903
15904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15905   unsigned long jresult ;
15906   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15907   Dali::Property::Map::SizeType result;
15908
15909   arg1 = (Dali::Property::Map *)jarg1;
15910   {
15911     try {
15912       result = ((Dali::Property::Map const *)arg1)->Count();
15913     } catch (std::out_of_range& e) {
15914       {
15915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15916       };
15917     } catch (std::exception& e) {
15918       {
15919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15920       };
15921     } catch (Dali::DaliException e) {
15922       {
15923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15924       };
15925     } catch (...) {
15926       {
15927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15928       };
15929     }
15930   }
15931
15932   jresult = (unsigned long)result;
15933   return jresult;
15934 }
15935
15936
15937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15938   unsigned int jresult ;
15939   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15940   bool result;
15941
15942   arg1 = (Dali::Property::Map *)jarg1;
15943   {
15944     try {
15945       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15946     } catch (std::out_of_range& e) {
15947       {
15948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15949       };
15950     } catch (std::exception& e) {
15951       {
15952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15953       };
15954     } catch (Dali::DaliException e) {
15955       {
15956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15957       };
15958     } catch (...) {
15959       {
15960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15961       };
15962     }
15963   }
15964
15965   jresult = result;
15966   return jresult;
15967 }
15968
15969
15970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15971   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15972   char *arg2 = (char *) 0 ;
15973   Dali::Property::Value *arg3 = 0 ;
15974
15975   arg1 = (Dali::Property::Map *)jarg1;
15976   arg2 = (char *)jarg2;
15977   arg3 = (Dali::Property::Value *)jarg3;
15978   if (!arg3) {
15979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15980     return ;
15981   }
15982   {
15983     try {
15984       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15985     } catch (std::out_of_range& e) {
15986       {
15987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15988       };
15989     } catch (std::exception& e) {
15990       {
15991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15992       };
15993     } catch (Dali::DaliException e) {
15994       {
15995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15996       };
15997     } catch (...) {
15998       {
15999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16000       };
16001     }
16002   }
16003
16004 }
16005
16006
16007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16008   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16009   Dali::Property::Index arg2 ;
16010   Dali::Property::Value *arg3 = 0 ;
16011
16012   arg1 = (Dali::Property::Map *)jarg1;
16013   arg2 = (Dali::Property::Index)jarg2;
16014   arg3 = (Dali::Property::Value *)jarg3;
16015   if (!arg3) {
16016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16017     return ;
16018   }
16019   {
16020     try {
16021       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16022     } catch (std::out_of_range& e) {
16023       {
16024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16025       };
16026     } catch (std::exception& e) {
16027       {
16028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16029       };
16030     } catch (Dali::DaliException e) {
16031       {
16032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16033       };
16034     } catch (...) {
16035       {
16036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16037       };
16038     }
16039   }
16040
16041 }
16042
16043
16044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16045   void * jresult ;
16046   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16047   char *arg2 = (char *) 0 ;
16048   Dali::Property::Value *arg3 = 0 ;
16049   Dali::Property::Map *result = 0 ;
16050
16051   arg1 = (Dali::Property::Map *)jarg1;
16052   arg2 = (char *)jarg2;
16053   arg3 = (Dali::Property::Value *)jarg3;
16054   if (!arg3) {
16055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16056     return 0;
16057   }
16058   {
16059     try {
16060       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16061     } catch (std::out_of_range& e) {
16062       {
16063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16064       };
16065     } catch (std::exception& e) {
16066       {
16067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16068       };
16069     } catch (Dali::DaliException e) {
16070       {
16071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16072       };
16073     } catch (...) {
16074       {
16075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16076       };
16077     }
16078   }
16079
16080   jresult = (void *)result;
16081   return jresult;
16082 }
16083
16084
16085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16086   void * jresult ;
16087   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16088   Dali::Property::Index arg2 ;
16089   Dali::Property::Value *arg3 = 0 ;
16090   Dali::Property::Map *result = 0 ;
16091
16092   arg1 = (Dali::Property::Map *)jarg1;
16093   arg2 = (Dali::Property::Index)jarg2;
16094   arg3 = (Dali::Property::Value *)jarg3;
16095   if (!arg3) {
16096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16097     return 0;
16098   }
16099   {
16100     try {
16101       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16102     } catch (std::out_of_range& e) {
16103       {
16104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16105       };
16106     } catch (std::exception& e) {
16107       {
16108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16109       };
16110     } catch (Dali::DaliException e) {
16111       {
16112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16113       };
16114     } catch (...) {
16115       {
16116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16117       };
16118     }
16119   }
16120
16121   jresult = (void *)result;
16122   return jresult;
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16127   void * jresult ;
16128   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16129   Dali::Property::Map::SizeType arg2 ;
16130   Dali::Property::Value *result = 0 ;
16131
16132   arg1 = (Dali::Property::Map *)jarg1;
16133   arg2 = (Dali::Property::Map::SizeType)jarg2;
16134   {
16135     try {
16136       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16137     } catch (std::out_of_range& e) {
16138       {
16139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16140       };
16141     } catch (std::exception& e) {
16142       {
16143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (Dali::DaliException e) {
16146       {
16147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16148       };
16149     } catch (...) {
16150       {
16151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16152       };
16153     }
16154   }
16155
16156   jresult = (void *)result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16162   char * jresult ;
16163   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16164   Dali::Property::Map::SizeType arg2 ;
16165   std::string *result = 0 ;
16166
16167   arg1 = (Dali::Property::Map *)jarg1;
16168   arg2 = (Dali::Property::Map::SizeType)jarg2;
16169   {
16170     try {
16171       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16172     } catch (std::out_of_range& e) {
16173       {
16174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16175       };
16176     } catch (std::exception& e) {
16177       {
16178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (Dali::DaliException e) {
16181       {
16182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16183       };
16184     } catch (...) {
16185       {
16186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16187       };
16188     }
16189   }
16190
16191   jresult = SWIG_csharp_string_callback(result->c_str());
16192   return jresult;
16193 }
16194
16195
16196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16197   void * jresult ;
16198   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16199   Dali::Property::Map::SizeType arg2 ;
16200   SwigValueWrapper< Dali::Property::Key > result;
16201
16202   arg1 = (Dali::Property::Map *)jarg1;
16203   arg2 = (Dali::Property::Map::SizeType)jarg2;
16204   {
16205     try {
16206       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16207     } catch (std::out_of_range& e) {
16208       {
16209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16210       };
16211     } catch (std::exception& e) {
16212       {
16213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16214       };
16215     } catch (Dali::DaliException e) {
16216       {
16217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16218       };
16219     } catch (...) {
16220       {
16221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16222       };
16223     }
16224   }
16225
16226   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16227   return jresult;
16228 }
16229
16230
16231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16232   void * jresult ;
16233   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16234   Dali::Property::Map::SizeType arg2 ;
16235   StringValuePair *result = 0 ;
16236
16237   arg1 = (Dali::Property::Map *)jarg1;
16238   arg2 = (Dali::Property::Map::SizeType)jarg2;
16239   {
16240     try {
16241       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16242     } catch (std::out_of_range& e) {
16243       {
16244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16245       };
16246     } catch (std::exception& e) {
16247       {
16248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16249       };
16250     } catch (Dali::DaliException e) {
16251       {
16252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16253       };
16254     } catch (...) {
16255       {
16256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16257       };
16258     }
16259   }
16260
16261   jresult = (void *)result;
16262   return jresult;
16263 }
16264
16265
16266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16267   void * jresult ;
16268   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16269   char *arg2 = (char *) 0 ;
16270   Dali::Property::Value *result = 0 ;
16271
16272   arg1 = (Dali::Property::Map *)jarg1;
16273   arg2 = (char *)jarg2;
16274   {
16275     try {
16276       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16277     } catch (std::out_of_range& e) {
16278       {
16279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16280       };
16281     } catch (std::exception& e) {
16282       {
16283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16284       };
16285     } catch (Dali::DaliException e) {
16286       {
16287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16288       };
16289     } catch (...) {
16290       {
16291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16292       };
16293     }
16294   }
16295
16296   jresult = (void *)result;
16297   return jresult;
16298 }
16299
16300
16301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16302   void * jresult ;
16303   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16304   Dali::Property::Index arg2 ;
16305   Dali::Property::Value *result = 0 ;
16306
16307   arg1 = (Dali::Property::Map *)jarg1;
16308   arg2 = (Dali::Property::Index)jarg2;
16309   {
16310     try {
16311       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16312     } catch (std::out_of_range& e) {
16313       {
16314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16315       };
16316     } catch (std::exception& e) {
16317       {
16318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16319       };
16320     } catch (Dali::DaliException e) {
16321       {
16322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16323       };
16324     } catch (...) {
16325       {
16326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16327       };
16328     }
16329   }
16330
16331   jresult = (void *)result;
16332   return jresult;
16333 }
16334
16335
16336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16337   void * jresult ;
16338   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16339   Dali::Property::Index arg2 ;
16340   std::string *arg3 = 0 ;
16341   Dali::Property::Value *result = 0 ;
16342
16343   arg1 = (Dali::Property::Map *)jarg1;
16344   arg2 = (Dali::Property::Index)jarg2;
16345   if (!jarg3) {
16346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16347     return 0;
16348   }
16349   std::string arg3_str(jarg3);
16350   arg3 = &arg3_str;
16351   {
16352     try {
16353       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16354     } catch (std::out_of_range& e) {
16355       {
16356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16357       };
16358     } catch (std::exception& e) {
16359       {
16360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16361       };
16362     } catch (Dali::DaliException e) {
16363       {
16364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16365       };
16366     } catch (...) {
16367       {
16368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16369       };
16370     }
16371   }
16372
16373   jresult = (void *)result;
16374
16375   //argout typemap for const std::string&
16376
16377   return jresult;
16378 }
16379
16380
16381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16382   void * jresult ;
16383   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16384   std::string *arg2 = 0 ;
16385   Dali::Property::Type arg3 ;
16386   Dali::Property::Value *result = 0 ;
16387
16388   arg1 = (Dali::Property::Map *)jarg1;
16389   if (!jarg2) {
16390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16391     return 0;
16392   }
16393   std::string arg2_str(jarg2);
16394   arg2 = &arg2_str;
16395   arg3 = (Dali::Property::Type)jarg3;
16396   {
16397     try {
16398       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16399     } catch (std::out_of_range& e) {
16400       {
16401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16402       };
16403     } catch (std::exception& e) {
16404       {
16405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16406       };
16407     } catch (Dali::DaliException e) {
16408       {
16409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16410       };
16411     } catch (...) {
16412       {
16413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16414       };
16415     }
16416   }
16417
16418   jresult = (void *)result;
16419
16420   //argout typemap for const std::string&
16421
16422   return jresult;
16423 }
16424
16425
16426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16427   void * jresult ;
16428   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16429   Dali::Property::Index arg2 ;
16430   Dali::Property::Type arg3 ;
16431   Dali::Property::Value *result = 0 ;
16432
16433   arg1 = (Dali::Property::Map *)jarg1;
16434   arg2 = (Dali::Property::Index)jarg2;
16435   arg3 = (Dali::Property::Type)jarg3;
16436   {
16437     try {
16438       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16439     } catch (std::out_of_range& e) {
16440       {
16441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16442       };
16443     } catch (std::exception& e) {
16444       {
16445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16446       };
16447     } catch (Dali::DaliException e) {
16448       {
16449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16450       };
16451     } catch (...) {
16452       {
16453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16454       };
16455     }
16456   }
16457
16458   jresult = (void *)result;
16459   return jresult;
16460 }
16461
16462
16463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16464   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16465
16466   arg1 = (Dali::Property::Map *)jarg1;
16467   {
16468     try {
16469       (arg1)->Clear();
16470     } catch (std::out_of_range& e) {
16471       {
16472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16473       };
16474     } catch (std::exception& e) {
16475       {
16476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16477       };
16478     } catch (Dali::DaliException e) {
16479       {
16480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16481       };
16482     } catch (...) {
16483       {
16484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16485       };
16486     }
16487   }
16488
16489 }
16490
16491
16492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16493   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16494   Dali::Property::Map *arg2 = 0 ;
16495
16496   arg1 = (Dali::Property::Map *)jarg1;
16497   arg2 = (Dali::Property::Map *)jarg2;
16498   if (!arg2) {
16499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16500     return ;
16501   }
16502   {
16503     try {
16504       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16505     } catch (std::out_of_range& e) {
16506       {
16507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16508       };
16509     } catch (std::exception& e) {
16510       {
16511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16512       };
16513     } catch (Dali::DaliException e) {
16514       {
16515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16520       };
16521     }
16522   }
16523
16524 }
16525
16526
16527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16528   void * jresult ;
16529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16530   std::string *arg2 = 0 ;
16531   Dali::Property::Value *result = 0 ;
16532
16533   arg1 = (Dali::Property::Map *)jarg1;
16534   if (!jarg2) {
16535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16536     return 0;
16537   }
16538   std::string arg2_str(jarg2);
16539   arg2 = &arg2_str;
16540   {
16541     try {
16542       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16543     } catch (std::out_of_range& e) {
16544       {
16545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16546       };
16547     } catch (std::exception& e) {
16548       {
16549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16550       };
16551     } catch (Dali::DaliException e) {
16552       {
16553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16554       };
16555     } catch (...) {
16556       {
16557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16558       };
16559     }
16560   }
16561
16562   jresult = (void *)result;
16563
16564   //argout typemap for const std::string&
16565
16566   return jresult;
16567 }
16568
16569
16570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16571   void * jresult ;
16572   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16573   Dali::Property::Index arg2 ;
16574   Dali::Property::Value *result = 0 ;
16575
16576   arg1 = (Dali::Property::Map *)jarg1;
16577   arg2 = (Dali::Property::Index)jarg2;
16578   {
16579     try {
16580       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16581     } catch (std::out_of_range& e) {
16582       {
16583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16584       };
16585     } catch (std::exception& e) {
16586       {
16587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16588       };
16589     } catch (Dali::DaliException e) {
16590       {
16591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16592       };
16593     } catch (...) {
16594       {
16595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16596       };
16597     }
16598   }
16599
16600   jresult = (void *)result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16606   void * jresult ;
16607   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16608   Dali::Property::Map *arg2 = 0 ;
16609   Dali::Property::Map *result = 0 ;
16610
16611   arg1 = (Dali::Property::Map *)jarg1;
16612   arg2 = (Dali::Property::Map *)jarg2;
16613   if (!arg2) {
16614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16615     return 0;
16616   }
16617   {
16618     try {
16619       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16620     } catch (std::out_of_range& e) {
16621       {
16622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16623       };
16624     } catch (std::exception& e) {
16625       {
16626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16627       };
16628     } catch (Dali::DaliException e) {
16629       {
16630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16631       };
16632     } catch (...) {
16633       {
16634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16635       };
16636     }
16637   }
16638
16639   jresult = (void *)result;
16640   return jresult;
16641 }
16642
16643
16644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16645   void * jresult ;
16646   Dali::Property::Value *result = 0 ;
16647
16648   {
16649     try {
16650       result = (Dali::Property::Value *)new Dali::Property::Value();
16651     } catch (std::out_of_range& e) {
16652       {
16653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16654       };
16655     } catch (std::exception& e) {
16656       {
16657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16658       };
16659     } catch (Dali::DaliException e) {
16660       {
16661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16662       };
16663     } catch (...) {
16664       {
16665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16666       };
16667     }
16668   }
16669
16670   jresult = (void *)result;
16671   return jresult;
16672 }
16673
16674
16675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16676   void * jresult ;
16677   bool arg1 ;
16678   Dali::Property::Value *result = 0 ;
16679
16680   arg1 = jarg1 ? true : false;
16681   {
16682     try {
16683       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16684     } catch (std::out_of_range& e) {
16685       {
16686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16687       };
16688     } catch (std::exception& e) {
16689       {
16690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16691       };
16692     } catch (Dali::DaliException e) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16695       };
16696     } catch (...) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16699       };
16700     }
16701   }
16702
16703   jresult = (void *)result;
16704   return jresult;
16705 }
16706
16707
16708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16709   void * jresult ;
16710   int arg1 ;
16711   Dali::Property::Value *result = 0 ;
16712
16713   arg1 = (int)jarg1;
16714   {
16715     try {
16716       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16717     } catch (std::out_of_range& e) {
16718       {
16719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16720       };
16721     } catch (std::exception& e) {
16722       {
16723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (Dali::DaliException e) {
16726       {
16727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16728       };
16729     } catch (...) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16732       };
16733     }
16734   }
16735
16736   jresult = (void *)result;
16737   return jresult;
16738 }
16739
16740
16741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16742   void * jresult ;
16743   float arg1 ;
16744   Dali::Property::Value *result = 0 ;
16745
16746   arg1 = (float)jarg1;
16747   {
16748     try {
16749       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16750     } catch (std::out_of_range& e) {
16751       {
16752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16753       };
16754     } catch (std::exception& e) {
16755       {
16756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (Dali::DaliException e) {
16759       {
16760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16761       };
16762     } catch (...) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16765       };
16766     }
16767   }
16768
16769   jresult = (void *)result;
16770   return jresult;
16771 }
16772
16773
16774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16775   void * jresult ;
16776   Dali::Vector2 *arg1 = 0 ;
16777   Dali::Property::Value *result = 0 ;
16778
16779   arg1 = (Dali::Vector2 *)jarg1;
16780   if (!arg1) {
16781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16782     return 0;
16783   }
16784   {
16785     try {
16786       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = (void *)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16812   void * jresult ;
16813   Dali::Vector3 *arg1 = 0 ;
16814   Dali::Property::Value *result = 0 ;
16815
16816   arg1 = (Dali::Vector3 *)jarg1;
16817   if (!arg1) {
16818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16819     return 0;
16820   }
16821   {
16822     try {
16823       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16824     } catch (std::out_of_range& e) {
16825       {
16826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (std::exception& e) {
16829       {
16830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16831       };
16832     } catch (Dali::DaliException e) {
16833       {
16834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16835       };
16836     } catch (...) {
16837       {
16838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16839       };
16840     }
16841   }
16842
16843   jresult = (void *)result;
16844   return jresult;
16845 }
16846
16847
16848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16849   void * jresult ;
16850   Dali::Vector4 *arg1 = 0 ;
16851   Dali::Property::Value *result = 0 ;
16852
16853   arg1 = (Dali::Vector4 *)jarg1;
16854   if (!arg1) {
16855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16856     return 0;
16857   }
16858   {
16859     try {
16860       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16861     } catch (std::out_of_range& e) {
16862       {
16863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (std::exception& e) {
16866       {
16867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16868       };
16869     } catch (Dali::DaliException e) {
16870       {
16871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16876       };
16877     }
16878   }
16879
16880   jresult = (void *)result;
16881   return jresult;
16882 }
16883
16884
16885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16886   void * jresult ;
16887   Dali::Matrix3 *arg1 = 0 ;
16888   Dali::Property::Value *result = 0 ;
16889
16890   arg1 = (Dali::Matrix3 *)jarg1;
16891   if (!arg1) {
16892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16893     return 0;
16894   }
16895   {
16896     try {
16897       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (Dali::DaliException e) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16909       };
16910     } catch (...) {
16911       {
16912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16913       };
16914     }
16915   }
16916
16917   jresult = (void *)result;
16918   return jresult;
16919 }
16920
16921
16922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16923   void * jresult ;
16924   Dali::Matrix *arg1 = 0 ;
16925   Dali::Property::Value *result = 0 ;
16926
16927   arg1 = (Dali::Matrix *)jarg1;
16928   if (!arg1) {
16929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16930     return 0;
16931   }
16932   {
16933     try {
16934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16935     } catch (std::out_of_range& e) {
16936       {
16937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16938       };
16939     } catch (std::exception& e) {
16940       {
16941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (Dali::DaliException e) {
16944       {
16945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953
16954   jresult = (void *)result;
16955   return jresult;
16956 }
16957
16958
16959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16960   void * jresult ;
16961   Dali::Rect< int > *arg1 = 0 ;
16962   Dali::Property::Value *result = 0 ;
16963
16964   arg1 = (Dali::Rect< int > *)jarg1;
16965   if (!arg1) {
16966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16967     return 0;
16968   }
16969   {
16970     try {
16971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16972     } catch (std::out_of_range& e) {
16973       {
16974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16975       };
16976     } catch (std::exception& e) {
16977       {
16978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16979       };
16980     } catch (Dali::DaliException e) {
16981       {
16982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16983       };
16984     } catch (...) {
16985       {
16986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16987       };
16988     }
16989   }
16990
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16997   void * jresult ;
16998   Dali::AngleAxis *arg1 = 0 ;
16999   Dali::Property::Value *result = 0 ;
17000
17001   arg1 = (Dali::AngleAxis *)jarg1;
17002   if (!arg1) {
17003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17004     return 0;
17005   }
17006   {
17007     try {
17008       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (Dali::DaliException e) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17020       };
17021     } catch (...) {
17022       {
17023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17024       };
17025     }
17026   }
17027
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17034   void * jresult ;
17035   Dali::Quaternion *arg1 = 0 ;
17036   Dali::Property::Value *result = 0 ;
17037
17038   arg1 = (Dali::Quaternion *)jarg1;
17039   if (!arg1) {
17040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17041     return 0;
17042   }
17043   {
17044     try {
17045       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17046     } catch (std::out_of_range& e) {
17047       {
17048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (std::exception& e) {
17051       {
17052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17053       };
17054     } catch (Dali::DaliException e) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17057       };
17058     } catch (...) {
17059       {
17060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17061       };
17062     }
17063   }
17064
17065   jresult = (void *)result;
17066   return jresult;
17067 }
17068
17069
17070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17071   void * jresult ;
17072   std::string *arg1 = 0 ;
17073   Dali::Property::Value *result = 0 ;
17074
17075   if (!jarg1) {
17076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17077     return 0;
17078   }
17079   std::string arg1_str(jarg1);
17080   arg1 = &arg1_str;
17081   {
17082     try {
17083       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17084     } catch (std::out_of_range& e) {
17085       {
17086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17087       };
17088     } catch (std::exception& e) {
17089       {
17090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17091       };
17092     } catch (Dali::DaliException e) {
17093       {
17094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17095       };
17096     } catch (...) {
17097       {
17098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17099       };
17100     }
17101   }
17102
17103   jresult = (void *)result;
17104
17105   //argout typemap for const std::string&
17106
17107   return jresult;
17108 }
17109
17110
17111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17112   void * jresult ;
17113   Dali::Property::Array *arg1 = 0 ;
17114   Dali::Property::Value *result = 0 ;
17115
17116   arg1 = (Dali::Property::Array *)jarg1;
17117   if (!arg1) {
17118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17119     return 0;
17120   }
17121   {
17122     try {
17123       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17124     } catch (std::out_of_range& e) {
17125       {
17126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17127       };
17128     } catch (std::exception& e) {
17129       {
17130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17131       };
17132     } catch (Dali::DaliException e) {
17133       {
17134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17135       };
17136     } catch (...) {
17137       {
17138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17139       };
17140     }
17141   }
17142
17143   jresult = (void *)result;
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17149   void * jresult ;
17150   Dali::Property::Map *arg1 = 0 ;
17151   Dali::Property::Value *result = 0 ;
17152
17153   arg1 = (Dali::Property::Map *)jarg1;
17154   if (!arg1) {
17155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17156     return 0;
17157   }
17158   {
17159     try {
17160       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17161     } catch (std::out_of_range& e) {
17162       {
17163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (std::exception& e) {
17166       {
17167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17168       };
17169     } catch (Dali::DaliException e) {
17170       {
17171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17172       };
17173     } catch (...) {
17174       {
17175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17176       };
17177     }
17178   }
17179
17180   jresult = (void *)result;
17181   return jresult;
17182 }
17183
17184
17185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17186   void * jresult ;
17187   Extents *arg1 = 0 ;
17188   Dali::Property::Value *result = 0 ;
17189
17190   arg1 = (Extents *)jarg1;
17191   if (!arg1) {
17192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17193     return 0;
17194   }
17195   {
17196     try {
17197       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17198     } catch (std::out_of_range& e) {
17199       {
17200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (std::exception& e) {
17203       {
17204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17205       };
17206     } catch (...) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17209       };
17210     }
17211   }
17212   jresult = (void *)result;
17213   return jresult;
17214 }
17215
17216
17217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17218   void * jresult ;
17219   Dali::Property::Type arg1 ;
17220   Dali::Property::Value *result = 0 ;
17221
17222   arg1 = (Dali::Property::Type)jarg1;
17223   {
17224     try {
17225       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17226     } catch (std::out_of_range& e) {
17227       {
17228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17229       };
17230     } catch (std::exception& e) {
17231       {
17232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17233       };
17234     } catch (Dali::DaliException e) {
17235       {
17236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17237       };
17238     } catch (...) {
17239       {
17240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17241       };
17242     }
17243   }
17244
17245   jresult = (void *)result;
17246   return jresult;
17247 }
17248
17249
17250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17251   void * jresult ;
17252   Dali::Property::Value *arg1 = 0 ;
17253   Dali::Property::Value *result = 0 ;
17254
17255   arg1 = (Dali::Property::Value *)jarg1;
17256   if (!arg1) {
17257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17258     return 0;
17259   }
17260   {
17261     try {
17262       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17263     } catch (std::out_of_range& e) {
17264       {
17265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17266       };
17267     } catch (std::exception& e) {
17268       {
17269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (Dali::DaliException e) {
17272       {
17273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281
17282   jresult = (void *)result;
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17288   void * jresult ;
17289   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17290   Dali::Property::Value *arg2 = 0 ;
17291   Dali::Property::Value *result = 0 ;
17292
17293   arg1 = (Dali::Property::Value *)jarg1;
17294   arg2 = (Dali::Property::Value *)jarg2;
17295   if (!arg2) {
17296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17297     return 0;
17298   }
17299   {
17300     try {
17301       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17302     } catch (std::out_of_range& e) {
17303       {
17304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17305       };
17306     } catch (std::exception& e) {
17307       {
17308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17309       };
17310     } catch (Dali::DaliException e) {
17311       {
17312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17313       };
17314     } catch (...) {
17315       {
17316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17317       };
17318     }
17319   }
17320
17321   jresult = (void *)result;
17322   return jresult;
17323 }
17324
17325
17326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17327   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17328
17329   arg1 = (Dali::Property::Value *)jarg1;
17330   {
17331     try {
17332       delete arg1;
17333     } catch (std::out_of_range& e) {
17334       {
17335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17336       };
17337     } catch (std::exception& e) {
17338       {
17339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17340       };
17341     } catch (Dali::DaliException e) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17344       };
17345     } catch (...) {
17346       {
17347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17348       };
17349     }
17350   }
17351
17352 }
17353
17354
17355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17356   int jresult ;
17357   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17358   Dali::Property::Type result;
17359
17360   arg1 = (Dali::Property::Value *)jarg1;
17361   {
17362     try {
17363       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (Dali::DaliException e) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17375       };
17376     } catch (...) {
17377       {
17378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17379       };
17380     }
17381   }
17382
17383   jresult = (int)result;
17384   return jresult;
17385 }
17386
17387
17388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17389   unsigned int jresult ;
17390   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17391   bool *arg2 = 0 ;
17392   bool result;
17393
17394   arg1 = (Dali::Property::Value *)jarg1;
17395   arg2 = (bool *)jarg2;
17396   {
17397     try {
17398       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17399     } catch (std::out_of_range& e) {
17400       {
17401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17402       };
17403     } catch (std::exception& e) {
17404       {
17405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17406       };
17407     } catch (Dali::DaliException e) {
17408       {
17409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17410       };
17411     } catch (...) {
17412       {
17413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17414       };
17415     }
17416   }
17417
17418   jresult = result;
17419   return jresult;
17420 }
17421
17422
17423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17424   unsigned int jresult ;
17425   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17426   float *arg2 = 0 ;
17427   bool result;
17428
17429   arg1 = (Dali::Property::Value *)jarg1;
17430   arg2 = (float *)jarg2;
17431   {
17432     try {
17433       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17434     } catch (std::out_of_range& e) {
17435       {
17436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17437       };
17438     } catch (std::exception& e) {
17439       {
17440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17441       };
17442     } catch (Dali::DaliException e) {
17443       {
17444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17445       };
17446     } catch (...) {
17447       {
17448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17449       };
17450     }
17451   }
17452
17453   jresult = result;
17454   return jresult;
17455 }
17456
17457
17458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17459   unsigned int jresult ;
17460   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17461   int *arg2 = 0 ;
17462   bool result;
17463
17464   arg1 = (Dali::Property::Value *)jarg1;
17465   arg2 = (int *)jarg2;
17466   {
17467     try {
17468       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17469     } catch (std::out_of_range& e) {
17470       {
17471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17472       };
17473     } catch (std::exception& e) {
17474       {
17475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (Dali::DaliException e) {
17478       {
17479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487
17488   jresult = result;
17489   return jresult;
17490 }
17491
17492
17493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17494   unsigned int jresult ;
17495   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17496   Dali::Rect< int > *arg2 = 0 ;
17497   bool result;
17498
17499   arg1 = (Dali::Property::Value *)jarg1;
17500   arg2 = (Dali::Rect< int > *)jarg2;
17501   if (!arg2) {
17502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17503     return 0;
17504   }
17505   {
17506     try {
17507       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17508     } catch (std::out_of_range& e) {
17509       {
17510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17511       };
17512     } catch (std::exception& e) {
17513       {
17514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17515       };
17516     } catch (Dali::DaliException e) {
17517       {
17518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17519       };
17520     } catch (...) {
17521       {
17522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17523       };
17524     }
17525   }
17526
17527   jresult = result;
17528   return jresult;
17529 }
17530
17531
17532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17533   unsigned int jresult ;
17534   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17535   Dali::Vector2 *arg2 = 0 ;
17536   bool result;
17537
17538   arg1 = (Dali::Property::Value *)jarg1;
17539   arg2 = (Dali::Vector2 *)jarg2;
17540   if (!arg2) {
17541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17542     return 0;
17543   }
17544   {
17545     try {
17546       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17547     } catch (std::out_of_range& e) {
17548       {
17549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17550       };
17551     } catch (std::exception& e) {
17552       {
17553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17554       };
17555     } catch (Dali::DaliException e) {
17556       {
17557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17558       };
17559     } catch (...) {
17560       {
17561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17562       };
17563     }
17564   }
17565
17566   jresult = result;
17567   return jresult;
17568 }
17569
17570
17571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17572   unsigned int jresult ;
17573   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17574   Dali::Vector3 *arg2 = 0 ;
17575   bool result;
17576
17577   arg1 = (Dali::Property::Value *)jarg1;
17578   arg2 = (Dali::Vector3 *)jarg2;
17579   if (!arg2) {
17580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17581     return 0;
17582   }
17583   {
17584     try {
17585       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17586     } catch (std::out_of_range& e) {
17587       {
17588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17589       };
17590     } catch (std::exception& e) {
17591       {
17592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17593       };
17594     } catch (Dali::DaliException e) {
17595       {
17596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17597       };
17598     } catch (...) {
17599       {
17600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17601       };
17602     }
17603   }
17604
17605   jresult = result;
17606   return jresult;
17607 }
17608
17609
17610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17611   unsigned int jresult ;
17612   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17613   Dali::Vector4 *arg2 = 0 ;
17614   bool result;
17615
17616   arg1 = (Dali::Property::Value *)jarg1;
17617   arg2 = (Dali::Vector4 *)jarg2;
17618   if (!arg2) {
17619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17620     return 0;
17621   }
17622   {
17623     try {
17624       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (Dali::DaliException e) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17636       };
17637     } catch (...) {
17638       {
17639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17640       };
17641     }
17642   }
17643
17644   jresult = result;
17645   return jresult;
17646 }
17647
17648
17649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17650   unsigned int jresult ;
17651   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17652   Dali::Matrix3 *arg2 = 0 ;
17653   bool result;
17654
17655   arg1 = (Dali::Property::Value *)jarg1;
17656   arg2 = (Dali::Matrix3 *)jarg2;
17657   if (!arg2) {
17658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17659     return 0;
17660   }
17661   {
17662     try {
17663       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17664     } catch (std::out_of_range& e) {
17665       {
17666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17667       };
17668     } catch (std::exception& e) {
17669       {
17670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17671       };
17672     } catch (Dali::DaliException e) {
17673       {
17674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17675       };
17676     } catch (...) {
17677       {
17678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17679       };
17680     }
17681   }
17682
17683   jresult = result;
17684   return jresult;
17685 }
17686
17687
17688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17689   unsigned int jresult ;
17690   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17691   Dali::Matrix *arg2 = 0 ;
17692   bool result;
17693
17694   arg1 = (Dali::Property::Value *)jarg1;
17695   arg2 = (Dali::Matrix *)jarg2;
17696   if (!arg2) {
17697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17698     return 0;
17699   }
17700   {
17701     try {
17702       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17703     } catch (std::out_of_range& e) {
17704       {
17705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17706       };
17707     } catch (std::exception& e) {
17708       {
17709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17710       };
17711     } catch (Dali::DaliException e) {
17712       {
17713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17714       };
17715     } catch (...) {
17716       {
17717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17718       };
17719     }
17720   }
17721
17722   jresult = result;
17723   return jresult;
17724 }
17725
17726
17727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17728   unsigned int jresult ;
17729   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17730   Dali::AngleAxis *arg2 = 0 ;
17731   bool result;
17732
17733   arg1 = (Dali::Property::Value *)jarg1;
17734   arg2 = (Dali::AngleAxis *)jarg2;
17735   if (!arg2) {
17736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17737     return 0;
17738   }
17739   {
17740     try {
17741       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17742     } catch (std::out_of_range& e) {
17743       {
17744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17745       };
17746     } catch (std::exception& e) {
17747       {
17748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17749       };
17750     } catch (Dali::DaliException e) {
17751       {
17752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17753       };
17754     } catch (...) {
17755       {
17756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17757       };
17758     }
17759   }
17760
17761   jresult = result;
17762   return jresult;
17763 }
17764
17765
17766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17767   unsigned int jresult ;
17768   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17769   Dali::Quaternion *arg2 = 0 ;
17770   bool result;
17771
17772   arg1 = (Dali::Property::Value *)jarg1;
17773   arg2 = (Dali::Quaternion *)jarg2;
17774   if (!arg2) {
17775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17776     return 0;
17777   }
17778   {
17779     try {
17780       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17781     } catch (std::out_of_range& e) {
17782       {
17783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17784       };
17785     } catch (std::exception& e) {
17786       {
17787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17788       };
17789     } catch (Dali::DaliException e) {
17790       {
17791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17792       };
17793     } catch (...) {
17794       {
17795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17796       };
17797     }
17798   }
17799
17800   jresult = result;
17801   return jresult;
17802 }
17803
17804
17805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17806   unsigned int jresult ;
17807   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17808   std::string *arg2 = 0 ;
17809   bool result;
17810
17811   arg1 = (Dali::Property::Value *)jarg1;
17812
17813   //typemap in
17814   std::string temp;
17815   arg2 = &temp;
17816
17817   {
17818     try {
17819       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17820     } catch (std::out_of_range& e) {
17821       {
17822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (std::exception& e) {
17825       {
17826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17827       };
17828     } catch (Dali::DaliException e) {
17829       {
17830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17831       };
17832     } catch (...) {
17833       {
17834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17835       };
17836     }
17837   }
17838
17839   jresult = result;
17840
17841   //Typemap argout in c++ file.
17842   //This will convert c++ string to c# string
17843   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17844
17845   return jresult;
17846 }
17847
17848
17849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17850   unsigned int jresult ;
17851   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17852   Dali::Property::Array *arg2 = 0 ;
17853   bool result;
17854
17855   arg1 = (Dali::Property::Value *)jarg1;
17856   arg2 = (Dali::Property::Array *)jarg2;
17857   if (!arg2) {
17858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17859     return 0;
17860   }
17861   {
17862     try {
17863       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17864     } catch (std::out_of_range& e) {
17865       {
17866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17867       };
17868     } catch (std::exception& e) {
17869       {
17870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17871       };
17872     } catch (Dali::DaliException e) {
17873       {
17874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17875       };
17876     } catch (...) {
17877       {
17878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17879       };
17880     }
17881   }
17882
17883   jresult = result;
17884   return jresult;
17885 }
17886
17887
17888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17889   unsigned int jresult ;
17890   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17891   Dali::Property::Map *arg2 = 0 ;
17892   bool result;
17893
17894   arg1 = (Dali::Property::Value *)jarg1;
17895   arg2 = (Dali::Property::Map *)jarg2;
17896   if (!arg2) {
17897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17898     return 0;
17899   }
17900   {
17901     try {
17902       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17903     } catch (std::out_of_range& e) {
17904       {
17905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (std::exception& e) {
17908       {
17909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17910       };
17911     } catch (Dali::DaliException e) {
17912       {
17913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17914       };
17915     } catch (...) {
17916       {
17917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17918       };
17919     }
17920   }
17921
17922   jresult = result;
17923   return jresult;
17924 }
17925
17926
17927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17928   unsigned int jresult ;
17929   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17930   Extents *arg2 = 0 ;
17931   bool result;
17932
17933   arg1 = (Dali::Property::Value *)jarg1;
17934   arg2 = (Extents *)jarg2;
17935   if (!arg2) {
17936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17937     return 0;
17938   }
17939   {
17940     try {
17941       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17942     } catch (std::out_of_range& e) {
17943       {
17944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (std::exception& e) {
17947       {
17948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17949       };
17950     } catch (...) {
17951       {
17952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17953       };
17954     }
17955   }
17956   jresult = result;
17957   return jresult;
17958 }
17959
17960
17961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17962   void * jresult ;
17963   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17964   Dali::Property::Array *result = 0 ;
17965
17966   arg1 = (Dali::Property::Value *)jarg1;
17967   {
17968     try {
17969       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17970     } catch (std::out_of_range& e) {
17971       {
17972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17973       };
17974     } catch (std::exception& e) {
17975       {
17976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17977       };
17978     } catch (Dali::DaliException e) {
17979       {
17980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17981       };
17982     } catch (...) {
17983       {
17984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17985       };
17986     }
17987   }
17988
17989   jresult = (void *)result;
17990   return jresult;
17991 }
17992
17993
17994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17995   void * jresult ;
17996   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17997   Dali::Property::Map *result = 0 ;
17998
17999   arg1 = (Dali::Property::Value *)jarg1;
18000   {
18001     try {
18002       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18003     } catch (std::out_of_range& e) {
18004       {
18005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18006       };
18007     } catch (std::exception& e) {
18008       {
18009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (Dali::DaliException e) {
18012       {
18013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18014       };
18015     } catch (...) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18018       };
18019     }
18020   }
18021
18022   jresult = (void *)result;
18023   return jresult;
18024 }
18025
18026
18027 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18028   char * jresult ;
18029   Dali::Property::Type arg1 ;
18030   char *result = 0 ;
18031
18032   arg1 = (Dali::Property::Type)jarg1;
18033   {
18034     try {
18035       result = (char *)Dali::PropertyTypes::GetName(arg1);
18036     } catch (std::out_of_range& e) {
18037       {
18038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18039       };
18040     } catch (std::exception& e) {
18041       {
18042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (Dali::DaliException e) {
18045       {
18046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18047       };
18048     } catch (...) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18051       };
18052     }
18053   }
18054
18055   jresult = SWIG_csharp_string_callback((const char *)result);
18056   return jresult;
18057 }
18058
18059
18060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18061   unsigned int jresult ;
18062   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18063   std::string *arg2 = 0 ;
18064   Dali::Property::Map *arg3 = 0 ;
18065   bool result;
18066
18067   arg1 = (Dali::BaseObject *)jarg1;
18068   if (!jarg2) {
18069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18070     return 0;
18071   }
18072   std::string arg2_str(jarg2);
18073   arg2 = &arg2_str;
18074   arg3 = (Dali::Property::Map *)jarg3;
18075   if (!arg3) {
18076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18077     return 0;
18078   }
18079   {
18080     try {
18081       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18082     } catch (std::out_of_range& e) {
18083       {
18084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (std::exception& e) {
18087       {
18088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18089       };
18090     } catch (Dali::DaliException e) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18093       };
18094     } catch (...) {
18095       {
18096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18097       };
18098     }
18099   }
18100
18101   jresult = result;
18102
18103   //argout typemap for const std::string&
18104
18105   return jresult;
18106 }
18107
18108
18109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18110   char * jresult ;
18111   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18112   std::string *result = 0 ;
18113
18114   arg1 = (Dali::BaseObject *)jarg1;
18115   {
18116     try {
18117       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18118     } catch (std::out_of_range& e) {
18119       {
18120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18121       };
18122     } catch (std::exception& e) {
18123       {
18124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18125       };
18126     } catch (Dali::DaliException e) {
18127       {
18128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18129       };
18130     } catch (...) {
18131       {
18132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18133       };
18134     }
18135   }
18136
18137   jresult = SWIG_csharp_string_callback(result->c_str());
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18143   unsigned int jresult ;
18144   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18145   Dali::TypeInfo *arg2 = 0 ;
18146   bool result;
18147
18148   arg1 = (Dali::BaseObject *)jarg1;
18149   arg2 = (Dali::TypeInfo *)jarg2;
18150   if (!arg2) {
18151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18152     return 0;
18153   }
18154   {
18155     try {
18156       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18157     } catch (std::out_of_range& e) {
18158       {
18159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (std::exception& e) {
18162       {
18163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18164       };
18165     } catch (Dali::DaliException e) {
18166       {
18167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18168       };
18169     } catch (...) {
18170       {
18171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18172       };
18173     }
18174   }
18175
18176   jresult = result;
18177   return jresult;
18178 }
18179
18180
18181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18182   unsigned int jresult ;
18183   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18184   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18185   std::string *arg3 = 0 ;
18186   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18187   bool result;
18188
18189   arg1 = (Dali::BaseObject *)jarg1;
18190   arg2 = (ConnectionTrackerInterface *)jarg2;
18191   if (!jarg3) {
18192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18193     return 0;
18194   }
18195   std::string arg3_str(jarg3);
18196   arg3 = &arg3_str;
18197   arg4 = (FunctorDelegate *)jarg4;
18198   {
18199     try {
18200       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18201     } catch (std::out_of_range& e) {
18202       {
18203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18204       };
18205     } catch (std::exception& e) {
18206       {
18207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18208       };
18209     } catch (Dali::DaliException e) {
18210       {
18211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18212       };
18213     } catch (...) {
18214       {
18215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18216       };
18217     }
18218   }
18219
18220   jresult = result;
18221
18222   //argout typemap for const std::string&
18223
18224   return jresult;
18225 }
18226
18227
18228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18229   void * jresult ;
18230   Dali::BaseHandle *arg1 = 0 ;
18231   Dali::BaseObject *result = 0 ;
18232
18233   arg1 = (Dali::BaseHandle *)jarg1;
18234   if (!arg1) {
18235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18236     return 0;
18237   }
18238   {
18239     try {
18240       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18241     } catch (std::out_of_range& e) {
18242       {
18243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18244       };
18245     } catch (std::exception& e) {
18246       {
18247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18248       };
18249     } catch (Dali::DaliException e) {
18250       {
18251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18252       };
18253     } catch (...) {
18254       {
18255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18256       };
18257     }
18258   }
18259
18260   jresult = (void *)result;
18261   return jresult;
18262 }
18263
18264
18265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18266   void * jresult ;
18267   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18268   Dali::BaseHandle *result = 0 ;
18269
18270   arg1 = (Dali::BaseObject *)jarg1;
18271   {
18272     try {
18273       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18274     } catch (std::out_of_range& e) {
18275       {
18276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18277       };
18278     } catch (std::exception& e) {
18279       {
18280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18281       };
18282     } catch (Dali::DaliException e) {
18283       {
18284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18285       };
18286     } catch (...) {
18287       {
18288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18289       };
18290     }
18291   }
18292
18293   jresult = (void *)result;
18294   return jresult;
18295 }
18296
18297
18298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18299   void * jresult ;
18300   Dali::BaseHandle *result = 0 ;
18301
18302   {
18303     try {
18304       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18305     } catch (std::out_of_range& e) {
18306       {
18307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18308       };
18309     } catch (std::exception& e) {
18310       {
18311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18312       };
18313     } catch (Dali::DaliException e) {
18314       {
18315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18316       };
18317     } catch (...) {
18318       {
18319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18320       };
18321     }
18322   }
18323
18324   jresult = (void *)result;
18325   return jresult;
18326 }
18327
18328
18329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18330   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18331
18332   arg1 = (Dali::BaseHandle *)jarg1;
18333   {
18334     try {
18335       delete arg1;
18336     } catch (std::out_of_range& e) {
18337       {
18338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18339       };
18340     } catch (std::exception& e) {
18341       {
18342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18343       };
18344     } catch (Dali::DaliException e) {
18345       {
18346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18347       };
18348     } catch (...) {
18349       {
18350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18351       };
18352     }
18353   }
18354
18355 }
18356
18357
18358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18359   void * jresult ;
18360   Dali::BaseHandle *arg1 = 0 ;
18361   Dali::BaseHandle *result = 0 ;
18362
18363   arg1 = (Dali::BaseHandle *)jarg1;
18364   if (!arg1) {
18365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18366     return 0;
18367   }
18368   {
18369     try {
18370       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18371     } catch (std::out_of_range& e) {
18372       {
18373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18374       };
18375     } catch (std::exception& e) {
18376       {
18377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18378       };
18379     } catch (Dali::DaliException e) {
18380       {
18381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18382       };
18383     } catch (...) {
18384       {
18385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18386       };
18387     }
18388   }
18389
18390   jresult = (void *)result;
18391   return jresult;
18392 }
18393
18394
18395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18396   void * jresult ;
18397   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18398   Dali::BaseHandle *arg2 = 0 ;
18399   Dali::BaseHandle *result = 0 ;
18400
18401   arg1 = (Dali::BaseHandle *)jarg1;
18402   arg2 = (Dali::BaseHandle *)jarg2;
18403   if (!arg2) {
18404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18405     return 0;
18406   }
18407   {
18408     try {
18409       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18410     } catch (std::out_of_range& e) {
18411       {
18412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18413       };
18414     } catch (std::exception& e) {
18415       {
18416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18417       };
18418     } catch (Dali::DaliException e) {
18419       {
18420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18421       };
18422     } catch (...) {
18423       {
18424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18425       };
18426     }
18427   }
18428
18429   jresult = (void *)result;
18430   return jresult;
18431 }
18432
18433
18434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18435   unsigned int jresult ;
18436   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18437   std::string *arg2 = 0 ;
18438   Dali::Property::Map *arg3 = 0 ;
18439   bool result;
18440
18441   arg1 = (Dali::BaseHandle *)jarg1;
18442   if (!jarg2) {
18443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18444     return 0;
18445   }
18446   std::string arg2_str(jarg2);
18447   arg2 = &arg2_str;
18448   arg3 = (Dali::Property::Map *)jarg3;
18449   if (!arg3) {
18450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18451     return 0;
18452   }
18453   {
18454     try {
18455       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18456     } catch (std::out_of_range& e) {
18457       {
18458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18459       };
18460     } catch (std::exception& e) {
18461       {
18462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18463       };
18464     } catch (Dali::DaliException e) {
18465       {
18466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18467       };
18468     } catch (...) {
18469       {
18470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18471       };
18472     }
18473   }
18474
18475   jresult = result;
18476
18477   //argout typemap for const std::string&
18478
18479   return jresult;
18480 }
18481
18482
18483 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18484   char * jresult ;
18485   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18486   std::string *result = 0 ;
18487
18488   arg1 = (Dali::BaseHandle *)jarg1;
18489   {
18490     try {
18491       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18492     } catch (std::out_of_range& e) {
18493       {
18494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18495       };
18496     } catch (std::exception& e) {
18497       {
18498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18499       };
18500     } catch (Dali::DaliException e) {
18501       {
18502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18503       };
18504     } catch (...) {
18505       {
18506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18507       };
18508     }
18509   }
18510
18511   jresult = SWIG_csharp_string_callback(result->c_str());
18512   return jresult;
18513 }
18514
18515
18516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18517   unsigned int jresult ;
18518   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18519   Dali::TypeInfo *arg2 = 0 ;
18520   bool result;
18521
18522   arg1 = (Dali::BaseHandle *)jarg1;
18523   arg2 = (Dali::TypeInfo *)jarg2;
18524   if (!arg2) {
18525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18526     return 0;
18527   }
18528   {
18529     try {
18530       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (Dali::DaliException e) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549
18550   jresult = result;
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18556   void * jresult ;
18557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18558   Dali::BaseObject *result = 0 ;
18559
18560   arg1 = (Dali::BaseHandle *)jarg1;
18561   {
18562     try {
18563       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18564     } catch (std::out_of_range& e) {
18565       {
18566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18567       };
18568     } catch (std::exception& e) {
18569       {
18570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (Dali::DaliException e) {
18573       {
18574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18575       };
18576     } catch (...) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18579       };
18580     }
18581   }
18582
18583   jresult = (void *)result;
18584   return jresult;
18585 }
18586
18587
18588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18589   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18590
18591   arg1 = (Dali::BaseHandle *)jarg1;
18592   {
18593     try {
18594       (arg1)->Reset();
18595     } catch (std::out_of_range& e) {
18596       {
18597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18598       };
18599     } catch (std::exception& e) {
18600       {
18601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18602       };
18603     } catch (Dali::DaliException e) {
18604       {
18605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18606       };
18607     } catch (...) {
18608       {
18609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18610       };
18611     }
18612   }
18613
18614 }
18615
18616
18617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18618   unsigned int jresult ;
18619   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18620   Dali::BaseHandle *arg2 = 0 ;
18621   bool result;
18622
18623   arg1 = (Dali::BaseHandle *)jarg1;
18624   arg2 = (Dali::BaseHandle *)jarg2;
18625   if (!arg2) {
18626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18627     return 0;
18628   }
18629   {
18630     try {
18631       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18632     } catch (std::out_of_range& e) {
18633       {
18634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18635       };
18636     } catch (std::exception& e) {
18637       {
18638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18639       };
18640     } catch (Dali::DaliException e) {
18641       {
18642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18643       };
18644     } catch (...) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18647       };
18648     }
18649   }
18650
18651   jresult = result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18657   unsigned int jresult ;
18658   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18659   Dali::BaseHandle *arg2 = 0 ;
18660   bool result;
18661
18662   arg1 = (Dali::BaseHandle *)jarg1;
18663   arg2 = (Dali::BaseHandle *)jarg2;
18664   if (!arg2) {
18665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18666     return 0;
18667   }
18668   {
18669     try {
18670       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18671     } catch (std::out_of_range& e) {
18672       {
18673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18674       };
18675     } catch (std::exception& e) {
18676       {
18677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18678       };
18679     } catch (Dali::DaliException e) {
18680       {
18681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18682       };
18683     } catch (...) {
18684       {
18685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18686       };
18687     }
18688   }
18689
18690   jresult = result;
18691   return jresult;
18692 }
18693
18694
18695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18696   void * jresult ;
18697   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18698   Dali::RefObject *result = 0 ;
18699
18700   arg1 = (Dali::BaseHandle *)jarg1;
18701   {
18702     try {
18703       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18704     } catch (std::out_of_range& e) {
18705       {
18706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (std::exception& e) {
18709       {
18710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (Dali::DaliException e) {
18713       {
18714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18715       };
18716     } catch (...) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18719       };
18720     }
18721   }
18722
18723   jresult = (void *)result;
18724   return jresult;
18725 }
18726
18727
18728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18729   unsigned int jresult ;
18730   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18731   bool result;
18732
18733   arg1 = (Dali::BaseHandle *)jarg1;
18734   {
18735     try {
18736       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18737     } catch (std::out_of_range& e) {
18738       {
18739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18740       };
18741     } catch (std::exception& e) {
18742       {
18743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (Dali::DaliException e) {
18746       {
18747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18748       };
18749     } catch (...) {
18750       {
18751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18752       };
18753     }
18754   }
18755
18756   jresult = result;
18757   return jresult;
18758 }
18759
18760
18761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18762   unsigned int jresult ;
18763   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18764   Dali::BaseHandle *arg2 = 0 ;
18765   bool result;
18766
18767   arg1 = (Dali::BaseHandle *)jarg1;
18768   arg2 = (Dali::BaseHandle *)jarg2;
18769   if (!arg2) {
18770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18771     return 0;
18772   }
18773   {
18774     try {
18775       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18776     } catch (std::out_of_range& e) {
18777       {
18778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18779       };
18780     } catch (std::exception& e) {
18781       {
18782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18783       };
18784     } catch (Dali::DaliException e) {
18785       {
18786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18787       };
18788     } catch (...) {
18789       {
18790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18791       };
18792     }
18793   }
18794
18795   jresult = result;
18796   return jresult;
18797 }
18798
18799
18800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18801   unsigned int jresult ;
18802   Dali::BaseHandle *arg1 = 0 ;
18803   Dali::BaseHandle *arg2 = 0 ;
18804   bool result;
18805
18806   arg1 = (Dali::BaseHandle *)jarg1;
18807   if (!arg1) {
18808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18809     return 0;
18810   }
18811   arg2 = (Dali::BaseHandle *)jarg2;
18812   if (!arg2) {
18813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18814     return 0;
18815   }
18816   {
18817     try {
18818       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18819     } catch (std::out_of_range& e) {
18820       {
18821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (std::exception& e) {
18824       {
18825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18826       };
18827     } catch (Dali::DaliException e) {
18828       {
18829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18830       };
18831     } catch (...) {
18832       {
18833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18834       };
18835     }
18836   }
18837
18838   jresult = result;
18839   return jresult;
18840 }
18841
18842
18843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18844   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18845
18846   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18847   {
18848     try {
18849       delete arg1;
18850     } catch (std::out_of_range& e) {
18851       {
18852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18853       };
18854     } catch (std::exception& e) {
18855       {
18856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18857       };
18858     } catch (Dali::DaliException e) {
18859       {
18860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18861       };
18862     } catch (...) {
18863       {
18864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18865       };
18866     }
18867   }
18868
18869 }
18870
18871
18872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18873   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18874   SlotObserver *arg2 = (SlotObserver *) 0 ;
18875   CallbackBase *arg3 = (CallbackBase *) 0 ;
18876
18877   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18878   arg2 = (SlotObserver *)jarg2;
18879   arg3 = (CallbackBase *)jarg3;
18880   {
18881     try {
18882       (arg1)->SignalConnected(arg2,arg3);
18883     } catch (std::out_of_range& e) {
18884       {
18885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18886       };
18887     } catch (std::exception& e) {
18888       {
18889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (Dali::DaliException e) {
18892       {
18893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18894       };
18895     } catch (...) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18898       };
18899     }
18900   }
18901
18902 }
18903
18904
18905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18906   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18907
18908   arg1 = (Dali::SignalObserver *)jarg1;
18909   {
18910     try {
18911       delete arg1;
18912     } catch (std::out_of_range& e) {
18913       {
18914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18915       };
18916     } catch (std::exception& e) {
18917       {
18918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18919       };
18920     } catch (Dali::DaliException e) {
18921       {
18922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18923       };
18924     } catch (...) {
18925       {
18926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18927       };
18928     }
18929   }
18930
18931 }
18932
18933
18934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18935   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18936   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18937   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18938
18939   arg1 = (Dali::SignalObserver *)jarg1;
18940   arg2 = (Dali::SlotObserver *)jarg2;
18941   arg3 = (Dali::CallbackBase *)jarg3;
18942   {
18943     try {
18944       (arg1)->SignalDisconnected(arg2,arg3);
18945     } catch (std::out_of_range& e) {
18946       {
18947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18948       };
18949     } catch (std::exception& e) {
18950       {
18951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18952       };
18953     } catch (Dali::DaliException e) {
18954       {
18955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18956       };
18957     } catch (...) {
18958       {
18959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18960       };
18961     }
18962   }
18963
18964 }
18965
18966
18967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18968   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18969
18970   arg1 = (Dali::SlotObserver *)jarg1;
18971   {
18972     try {
18973       delete arg1;
18974     } catch (std::out_of_range& e) {
18975       {
18976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18977       };
18978     } catch (std::exception& e) {
18979       {
18980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18981       };
18982     } catch (Dali::DaliException e) {
18983       {
18984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18985       };
18986     } catch (...) {
18987       {
18988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18989       };
18990     }
18991   }
18992
18993 }
18994
18995
18996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18997   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18998   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18999
19000   arg1 = (Dali::SlotObserver *)jarg1;
19001   arg2 = (Dali::CallbackBase *)jarg2;
19002   {
19003     try {
19004       (arg1)->SlotDisconnected(arg2);
19005     } catch (std::out_of_range& e) {
19006       {
19007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19008       };
19009     } catch (std::exception& e) {
19010       {
19011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19012       };
19013     } catch (Dali::DaliException e) {
19014       {
19015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19016       };
19017     } catch (...) {
19018       {
19019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19020       };
19021     }
19022   }
19023
19024 }
19025
19026
19027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19028   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19029
19030   arg1 = (Dali::ConnectionTracker *)jarg1;
19031   {
19032     try {
19033       delete arg1;
19034     } catch (std::out_of_range& e) {
19035       {
19036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19037       };
19038     } catch (std::exception& e) {
19039       {
19040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19041       };
19042     } catch (Dali::DaliException e) {
19043       {
19044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19045       };
19046     } catch (...) {
19047       {
19048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19049       };
19050     }
19051   }
19052
19053 }
19054
19055
19056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19057   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19058
19059   arg1 = (Dali::ConnectionTracker *)jarg1;
19060   {
19061     try {
19062       (arg1)->DisconnectAll();
19063     } catch (std::out_of_range& e) {
19064       {
19065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19066       };
19067     } catch (std::exception& e) {
19068       {
19069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19070       };
19071     } catch (Dali::DaliException e) {
19072       {
19073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19074       };
19075     } catch (...) {
19076       {
19077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19078       };
19079     }
19080   }
19081
19082 }
19083
19084
19085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19086   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19087   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19088   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19089
19090   arg1 = (Dali::ConnectionTracker *)jarg1;
19091   arg2 = (Dali::SlotObserver *)jarg2;
19092   arg3 = (Dali::CallbackBase *)jarg3;
19093   {
19094     try {
19095       (arg1)->SignalConnected(arg2,arg3);
19096     } catch (std::out_of_range& e) {
19097       {
19098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19099       };
19100     } catch (std::exception& e) {
19101       {
19102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19103       };
19104     } catch (Dali::DaliException e) {
19105       {
19106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19107       };
19108     } catch (...) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19111       };
19112     }
19113   }
19114
19115 }
19116
19117
19118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19119   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19120   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19121   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19122
19123   arg1 = (Dali::ConnectionTracker *)jarg1;
19124   arg2 = (Dali::SlotObserver *)jarg2;
19125   arg3 = (Dali::CallbackBase *)jarg3;
19126   {
19127     try {
19128       (arg1)->SignalDisconnected(arg2,arg3);
19129     } catch (std::out_of_range& e) {
19130       {
19131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19132       };
19133     } catch (std::exception& e) {
19134       {
19135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19136       };
19137     } catch (Dali::DaliException e) {
19138       {
19139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19140       };
19141     } catch (...) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19144       };
19145     }
19146   }
19147
19148 }
19149
19150
19151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19152   unsigned long jresult ;
19153   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19154   std::size_t result;
19155
19156   arg1 = (Dali::ConnectionTracker *)jarg1;
19157   {
19158     try {
19159       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19160     } catch (std::out_of_range& e) {
19161       {
19162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (std::exception& e) {
19165       {
19166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19167       };
19168     } catch (Dali::DaliException e) {
19169       {
19170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19171       };
19172     } catch (...) {
19173       {
19174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19175       };
19176     }
19177   }
19178
19179   jresult = (unsigned long)result;
19180   return jresult;
19181 }
19182
19183
19184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19185   void * jresult ;
19186   Dali::ObjectRegistry *result = 0 ;
19187
19188   {
19189     try {
19190       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19191     } catch (std::out_of_range& e) {
19192       {
19193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (std::exception& e) {
19196       {
19197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19198       };
19199     } catch (Dali::DaliException e) {
19200       {
19201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19202       };
19203     } catch (...) {
19204       {
19205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19206       };
19207     }
19208   }
19209
19210   jresult = (void *)result;
19211   return jresult;
19212 }
19213
19214
19215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19216   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19217
19218   arg1 = (Dali::ObjectRegistry *)jarg1;
19219   {
19220     try {
19221       delete arg1;
19222     } catch (std::out_of_range& e) {
19223       {
19224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19225       };
19226     } catch (std::exception& e) {
19227       {
19228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19229       };
19230     } catch (Dali::DaliException e) {
19231       {
19232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19233       };
19234     } catch (...) {
19235       {
19236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19237       };
19238     }
19239   }
19240
19241 }
19242
19243
19244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19245   void * jresult ;
19246   Dali::ObjectRegistry *arg1 = 0 ;
19247   Dali::ObjectRegistry *result = 0 ;
19248
19249   arg1 = (Dali::ObjectRegistry *)jarg1;
19250   if (!arg1) {
19251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19252     return 0;
19253   }
19254   {
19255     try {
19256       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (Dali::DaliException e) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19268       };
19269     } catch (...) {
19270       {
19271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19272       };
19273     }
19274   }
19275
19276   jresult = (void *)result;
19277   return jresult;
19278 }
19279
19280
19281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19282   void * jresult ;
19283   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19284   Dali::ObjectRegistry *arg2 = 0 ;
19285   Dali::ObjectRegistry *result = 0 ;
19286
19287   arg1 = (Dali::ObjectRegistry *)jarg1;
19288   arg2 = (Dali::ObjectRegistry *)jarg2;
19289   if (!arg2) {
19290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19291     return 0;
19292   }
19293   {
19294     try {
19295       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19296     } catch (std::out_of_range& e) {
19297       {
19298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (std::exception& e) {
19301       {
19302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19303       };
19304     } catch (Dali::DaliException e) {
19305       {
19306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19307       };
19308     } catch (...) {
19309       {
19310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19311       };
19312     }
19313   }
19314
19315   jresult = (void *)result;
19316   return jresult;
19317 }
19318
19319
19320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19321   void * jresult ;
19322   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19323   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19324
19325   arg1 = (Dali::ObjectRegistry *)jarg1;
19326   {
19327     try {
19328       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19329     } catch (std::out_of_range& e) {
19330       {
19331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19332       };
19333     } catch (std::exception& e) {
19334       {
19335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19336       };
19337     } catch (Dali::DaliException e) {
19338       {
19339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19340       };
19341     } catch (...) {
19342       {
19343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19344       };
19345     }
19346   }
19347
19348   jresult = (void *)result;
19349   return jresult;
19350 }
19351
19352
19353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19354   void * jresult ;
19355   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19356   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19357
19358   arg1 = (Dali::ObjectRegistry *)jarg1;
19359   {
19360     try {
19361       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19362     } catch (std::out_of_range& e) {
19363       {
19364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19365       };
19366     } catch (std::exception& e) {
19367       {
19368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (Dali::DaliException e) {
19371       {
19372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19373       };
19374     } catch (...) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19377       };
19378     }
19379   }
19380
19381   jresult = (void *)result;
19382   return jresult;
19383 }
19384
19385
19386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19387   void * jresult ;
19388   Dali::PropertyCondition *result = 0 ;
19389
19390   {
19391     try {
19392       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19393     } catch (std::out_of_range& e) {
19394       {
19395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19396       };
19397     } catch (std::exception& e) {
19398       {
19399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19400       };
19401     } catch (Dali::DaliException e) {
19402       {
19403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19404       };
19405     } catch (...) {
19406       {
19407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19408       };
19409     }
19410   }
19411
19412   jresult = (void *)result;
19413   return jresult;
19414 }
19415
19416
19417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19418   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19419
19420   arg1 = (Dali::PropertyCondition *)jarg1;
19421   {
19422     try {
19423       delete arg1;
19424     } catch (std::out_of_range& e) {
19425       {
19426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19427       };
19428     } catch (std::exception& e) {
19429       {
19430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19431       };
19432     } catch (Dali::DaliException e) {
19433       {
19434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19435       };
19436     } catch (...) {
19437       {
19438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19439       };
19440     }
19441   }
19442
19443 }
19444
19445
19446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19447   void * jresult ;
19448   Dali::PropertyCondition *arg1 = 0 ;
19449   Dali::PropertyCondition *result = 0 ;
19450
19451   arg1 = (Dali::PropertyCondition *)jarg1;
19452   if (!arg1) {
19453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19454     return 0;
19455   }
19456   {
19457     try {
19458       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19459     } catch (std::out_of_range& e) {
19460       {
19461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19462       };
19463     } catch (std::exception& e) {
19464       {
19465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19466       };
19467     } catch (Dali::DaliException e) {
19468       {
19469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19470       };
19471     } catch (...) {
19472       {
19473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19474       };
19475     }
19476   }
19477
19478   jresult = (void *)result;
19479   return jresult;
19480 }
19481
19482
19483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19484   void * jresult ;
19485   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19486   Dali::PropertyCondition *arg2 = 0 ;
19487   Dali::PropertyCondition *result = 0 ;
19488
19489   arg1 = (Dali::PropertyCondition *)jarg1;
19490   arg2 = (Dali::PropertyCondition *)jarg2;
19491   if (!arg2) {
19492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19493     return 0;
19494   }
19495   {
19496     try {
19497       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19498     } catch (std::out_of_range& e) {
19499       {
19500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19501       };
19502     } catch (std::exception& e) {
19503       {
19504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19505       };
19506     } catch (Dali::DaliException e) {
19507       {
19508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19509       };
19510     } catch (...) {
19511       {
19512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19513       };
19514     }
19515   }
19516
19517   jresult = (void *)result;
19518   return jresult;
19519 }
19520
19521
19522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19523   unsigned long jresult ;
19524   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19525   std::size_t result;
19526
19527   arg1 = (Dali::PropertyCondition *)jarg1;
19528   {
19529     try {
19530       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19531     } catch (std::out_of_range& e) {
19532       {
19533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19534       };
19535     } catch (std::exception& e) {
19536       {
19537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (...) {
19540       {
19541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19542       };
19543     }
19544   }
19545   jresult = (unsigned long)result;
19546   return jresult;
19547 }
19548
19549
19550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19551   float jresult ;
19552   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19553   std::size_t arg2 ;
19554   float result;
19555
19556   arg1 = (Dali::PropertyCondition *)jarg1;
19557   arg2 = (std::size_t)jarg2;
19558   {
19559     try {
19560       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19561     } catch (std::out_of_range& e) {
19562       {
19563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19564       };
19565     } catch (std::exception& e) {
19566       {
19567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19568       };
19569     } catch (...) {
19570       {
19571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19572       };
19573     }
19574   }
19575   jresult = result;
19576   return jresult;
19577 }
19578
19579
19580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19581   void * jresult ;
19582   float arg1 ;
19583   Dali::PropertyCondition result;
19584
19585   arg1 = (float)jarg1;
19586   {
19587     try {
19588       result = Dali::LessThanCondition(arg1);
19589     } catch (std::out_of_range& e) {
19590       {
19591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (std::exception& e) {
19594       {
19595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19596       };
19597     } catch (Dali::DaliException e) {
19598       {
19599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19600       };
19601     } catch (...) {
19602       {
19603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19604       };
19605     }
19606   }
19607
19608   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19609   return jresult;
19610 }
19611
19612
19613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19614   void * jresult ;
19615   float arg1 ;
19616   Dali::PropertyCondition result;
19617
19618   arg1 = (float)jarg1;
19619   {
19620     try {
19621       result = Dali::GreaterThanCondition(arg1);
19622     } catch (std::out_of_range& e) {
19623       {
19624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (std::exception& e) {
19627       {
19628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19629       };
19630     } catch (Dali::DaliException e) {
19631       {
19632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19633       };
19634     } catch (...) {
19635       {
19636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19637       };
19638     }
19639   }
19640
19641   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19642   return jresult;
19643 }
19644
19645
19646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19647   void * jresult ;
19648   float arg1 ;
19649   float arg2 ;
19650   Dali::PropertyCondition result;
19651
19652   arg1 = (float)jarg1;
19653   arg2 = (float)jarg2;
19654   {
19655     try {
19656       result = Dali::InsideCondition(arg1,arg2);
19657     } catch (std::out_of_range& e) {
19658       {
19659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19660       };
19661     } catch (std::exception& e) {
19662       {
19663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19664       };
19665     } catch (Dali::DaliException e) {
19666       {
19667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19668       };
19669     } catch (...) {
19670       {
19671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19672       };
19673     }
19674   }
19675
19676   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19677   return jresult;
19678 }
19679
19680
19681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19682   void * jresult ;
19683   float arg1 ;
19684   float arg2 ;
19685   Dali::PropertyCondition result;
19686
19687   arg1 = (float)jarg1;
19688   arg2 = (float)jarg2;
19689   {
19690     try {
19691       result = Dali::OutsideCondition(arg1,arg2);
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19699       };
19700     } catch (Dali::DaliException e) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19703       };
19704     } catch (...) {
19705       {
19706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19707       };
19708     }
19709   }
19710
19711   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19712   return jresult;
19713 }
19714
19715
19716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19717   void * jresult ;
19718   float arg1 ;
19719   float arg2 ;
19720   Dali::PropertyCondition result;
19721
19722   arg1 = (float)jarg1;
19723   arg2 = (float)jarg2;
19724   {
19725     try {
19726       result = Dali::StepCondition(arg1,arg2);
19727     } catch (std::out_of_range& e) {
19728       {
19729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (std::exception& e) {
19732       {
19733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19734       };
19735     } catch (Dali::DaliException e) {
19736       {
19737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19738       };
19739     } catch (...) {
19740       {
19741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19742       };
19743     }
19744   }
19745
19746   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19752   void * jresult ;
19753   float arg1 ;
19754   Dali::PropertyCondition result;
19755
19756   arg1 = (float)jarg1;
19757   {
19758     try {
19759       result = Dali::StepCondition(arg1);
19760     } catch (std::out_of_range& e) {
19761       {
19762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (std::exception& e) {
19765       {
19766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (Dali::DaliException e) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19771       };
19772     } catch (...) {
19773       {
19774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19775       };
19776     }
19777   }
19778
19779   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19780   return jresult;
19781 }
19782
19783
19784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19785   void * jresult ;
19786   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19787   Dali::PropertyCondition result;
19788
19789   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19790   if (!arg1) {
19791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19792     return 0;
19793   }
19794   {
19795     try {
19796       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (Dali::DaliException e) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19808       };
19809     } catch (...) {
19810       {
19811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19812       };
19813     }
19814   }
19815
19816   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19817   return jresult;
19818 }
19819
19820
19821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19822   void * jresult ;
19823   Dali::PropertyNotification *result = 0 ;
19824
19825   {
19826     try {
19827       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19828     } catch (std::out_of_range& e) {
19829       {
19830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19831       };
19832     } catch (std::exception& e) {
19833       {
19834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19835       };
19836     } catch (Dali::DaliException e) {
19837       {
19838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19839       };
19840     } catch (...) {
19841       {
19842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19843       };
19844     }
19845   }
19846
19847   jresult = (void *)result;
19848   return jresult;
19849 }
19850
19851
19852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19853   void * jresult ;
19854   Dali::BaseHandle arg1 ;
19855   Dali::BaseHandle *argp1 ;
19856   Dali::PropertyNotification result;
19857
19858   argp1 = (Dali::BaseHandle *)jarg1;
19859   if (!argp1) {
19860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19861     return 0;
19862   }
19863   arg1 = *argp1;
19864   {
19865     try {
19866       result = Dali::PropertyNotification::DownCast(arg1);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19874       };
19875     } catch (Dali::DaliException e) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19878       };
19879     } catch (...) {
19880       {
19881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19882       };
19883     }
19884   }
19885
19886   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19887   return jresult;
19888 }
19889
19890
19891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19892   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19893
19894   arg1 = (Dali::PropertyNotification *)jarg1;
19895   {
19896     try {
19897       delete arg1;
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19913       };
19914     }
19915   }
19916
19917 }
19918
19919
19920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19921   void * jresult ;
19922   Dali::PropertyNotification *arg1 = 0 ;
19923   Dali::PropertyNotification *result = 0 ;
19924
19925   arg1 = (Dali::PropertyNotification *)jarg1;
19926   if (!arg1) {
19927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19928     return 0;
19929   }
19930   {
19931     try {
19932       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19933     } catch (std::out_of_range& e) {
19934       {
19935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19936       };
19937     } catch (std::exception& e) {
19938       {
19939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19940       };
19941     } catch (Dali::DaliException e) {
19942       {
19943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19944       };
19945     } catch (...) {
19946       {
19947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19948       };
19949     }
19950   }
19951
19952   jresult = (void *)result;
19953   return jresult;
19954 }
19955
19956
19957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19958   void * jresult ;
19959   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19960   Dali::PropertyNotification *arg2 = 0 ;
19961   Dali::PropertyNotification *result = 0 ;
19962
19963   arg1 = (Dali::PropertyNotification *)jarg1;
19964   arg2 = (Dali::PropertyNotification *)jarg2;
19965   if (!arg2) {
19966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19967     return 0;
19968   }
19969   {
19970     try {
19971       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19972     } catch (std::out_of_range& e) {
19973       {
19974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19975       };
19976     } catch (std::exception& e) {
19977       {
19978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19979       };
19980     } catch (Dali::DaliException e) {
19981       {
19982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19983       };
19984     } catch (...) {
19985       {
19986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19987       };
19988     }
19989   }
19990
19991   jresult = (void *)result;
19992   return jresult;
19993 }
19994
19995
19996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19997   void * jresult ;
19998   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19999   Dali::PropertyCondition result;
20000
20001   arg1 = (Dali::PropertyNotification *)jarg1;
20002   {
20003     try {
20004       result = (arg1)->GetCondition();
20005     } catch (std::out_of_range& e) {
20006       {
20007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20008       };
20009     } catch (std::exception& e) {
20010       {
20011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20012       };
20013     } catch (Dali::DaliException e) {
20014       {
20015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20016       };
20017     } catch (...) {
20018       {
20019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20020       };
20021     }
20022   }
20023
20024   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20025   return jresult;
20026 }
20027
20028
20029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20030   void * jresult ;
20031   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20032   Dali::Handle result;
20033
20034   arg1 = (Dali::PropertyNotification *)jarg1;
20035   {
20036     try {
20037       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20038     } catch (std::out_of_range& e) {
20039       {
20040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20041       };
20042     } catch (std::exception& e) {
20043       {
20044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (Dali::DaliException e) {
20047       {
20048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20049       };
20050     } catch (...) {
20051       {
20052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20053       };
20054     }
20055   }
20056
20057   jresult = new Dali::Handle((const Dali::Handle &)result);
20058   return jresult;
20059 }
20060
20061
20062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20063   int jresult ;
20064   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20065   Dali::Property::Index result;
20066
20067   arg1 = (Dali::PropertyNotification *)jarg1;
20068   {
20069     try {
20070       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20071     } catch (std::out_of_range& e) {
20072       {
20073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20074       };
20075     } catch (std::exception& e) {
20076       {
20077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20078       };
20079     } catch (Dali::DaliException e) {
20080       {
20081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20082       };
20083     } catch (...) {
20084       {
20085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20086       };
20087     }
20088   }
20089
20090   jresult = result;
20091   return jresult;
20092 }
20093
20094
20095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20096   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20097   Dali::PropertyNotification::NotifyMode arg2 ;
20098
20099   arg1 = (Dali::PropertyNotification *)jarg1;
20100   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20101   {
20102     try {
20103       (arg1)->SetNotifyMode(arg2);
20104     } catch (std::out_of_range& e) {
20105       {
20106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20107       };
20108     } catch (std::exception& e) {
20109       {
20110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20111       };
20112     } catch (Dali::DaliException e) {
20113       {
20114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20115       };
20116     } catch (...) {
20117       {
20118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20119       };
20120     }
20121   }
20122
20123 }
20124
20125
20126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20127   int jresult ;
20128   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20129   Dali::PropertyNotification::NotifyMode result;
20130
20131   arg1 = (Dali::PropertyNotification *)jarg1;
20132   {
20133     try {
20134       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20135     } catch (std::out_of_range& e) {
20136       {
20137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20138       };
20139     } catch (std::exception& e) {
20140       {
20141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20142       };
20143     } catch (Dali::DaliException e) {
20144       {
20145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20146       };
20147     } catch (...) {
20148       {
20149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20150       };
20151     }
20152   }
20153
20154   jresult = (int)result;
20155   return jresult;
20156 }
20157
20158
20159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20160   unsigned int jresult ;
20161   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20162   bool result;
20163
20164   arg1 = (Dali::PropertyNotification *)jarg1;
20165   {
20166     try {
20167       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20168     } catch (std::out_of_range& e) {
20169       {
20170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20171       };
20172     } catch (std::exception& e) {
20173       {
20174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20175       };
20176     } catch (Dali::DaliException e) {
20177       {
20178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20179       };
20180     } catch (...) {
20181       {
20182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20183       };
20184     }
20185   }
20186
20187   jresult = result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20193   void * jresult ;
20194   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20195   Dali::PropertyNotifySignalType *result = 0 ;
20196
20197   arg1 = (Dali::PropertyNotification *)jarg1;
20198   {
20199     try {
20200       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20201     } catch (std::out_of_range& e) {
20202       {
20203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20204       };
20205     } catch (std::exception& e) {
20206       {
20207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20208       };
20209     } catch (Dali::DaliException e) {
20210       {
20211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20212       };
20213     } catch (...) {
20214       {
20215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20216       };
20217     }
20218   }
20219
20220   jresult = (void *)result;
20221   return jresult;
20222 }
20223
20224
20225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20226   void * jresult ;
20227   Dali::Handle *result = 0 ;
20228
20229   {
20230     try {
20231       result = (Dali::Handle *)new Dali::Handle();
20232     } catch (std::out_of_range& e) {
20233       {
20234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20235       };
20236     } catch (std::exception& e) {
20237       {
20238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20239       };
20240     } catch (Dali::DaliException e) {
20241       {
20242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20243       };
20244     } catch (...) {
20245       {
20246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20247       };
20248     }
20249   }
20250
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20257   void * jresult ;
20258   Dali::Handle result;
20259
20260   {
20261     try {
20262       result = Dali::Handle::New();
20263     } catch (std::out_of_range& e) {
20264       {
20265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20266       };
20267     } catch (std::exception& e) {
20268       {
20269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20270       };
20271     } catch (Dali::DaliException e) {
20272       {
20273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20274       };
20275     } catch (...) {
20276       {
20277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20278       };
20279     }
20280   }
20281
20282   jresult = new Dali::Handle((const Dali::Handle &)result);
20283   return jresult;
20284 }
20285
20286
20287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20288   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20289
20290   arg1 = (Dali::Handle *)jarg1;
20291   {
20292     try {
20293       delete arg1;
20294     } catch (std::out_of_range& e) {
20295       {
20296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20297       };
20298     } catch (std::exception& e) {
20299       {
20300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20301       };
20302     } catch (Dali::DaliException e) {
20303       {
20304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20305       };
20306     } catch (...) {
20307       {
20308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20309       };
20310     }
20311   }
20312
20313 }
20314
20315
20316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20317   void * jresult ;
20318   Dali::Handle *arg1 = 0 ;
20319   Dali::Handle *result = 0 ;
20320
20321   arg1 = (Dali::Handle *)jarg1;
20322   if (!arg1) {
20323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20324     return 0;
20325   }
20326   {
20327     try {
20328       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20329     } catch (std::out_of_range& e) {
20330       {
20331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20332       };
20333     } catch (std::exception& e) {
20334       {
20335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20336       };
20337     } catch (Dali::DaliException e) {
20338       {
20339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20340       };
20341     } catch (...) {
20342       {
20343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20344       };
20345     }
20346   }
20347
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20354   void * jresult ;
20355   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20356   Dali::Handle *arg2 = 0 ;
20357   Dali::Handle *result = 0 ;
20358
20359   arg1 = (Dali::Handle *)jarg1;
20360   arg2 = (Dali::Handle *)jarg2;
20361   if (!arg2) {
20362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20363     return 0;
20364   }
20365   {
20366     try {
20367       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20368     } catch (std::out_of_range& e) {
20369       {
20370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20371       };
20372     } catch (std::exception& e) {
20373       {
20374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20375       };
20376     } catch (Dali::DaliException e) {
20377       {
20378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20379       };
20380     } catch (...) {
20381       {
20382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20383       };
20384     }
20385   }
20386
20387   jresult = (void *)result;
20388   return jresult;
20389 }
20390
20391
20392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20393   void * jresult ;
20394   Dali::BaseHandle arg1 ;
20395   Dali::BaseHandle *argp1 ;
20396   Dali::Handle result;
20397
20398   argp1 = (Dali::BaseHandle *)jarg1;
20399   if (!argp1) {
20400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20401     return 0;
20402   }
20403   arg1 = *argp1;
20404   {
20405     try {
20406       result = Dali::Handle::DownCast(arg1);
20407     } catch (std::out_of_range& e) {
20408       {
20409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20410       };
20411     } catch (std::exception& e) {
20412       {
20413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20414       };
20415     } catch (Dali::DaliException e) {
20416       {
20417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20418       };
20419     } catch (...) {
20420       {
20421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20422       };
20423     }
20424   }
20425
20426   jresult = new Dali::Handle((const Dali::Handle &)result);
20427   return jresult;
20428 }
20429
20430
20431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20432   unsigned int jresult ;
20433   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20434   Dali::Handle::Capability arg2 ;
20435   bool result;
20436
20437   arg1 = (Dali::Handle *)jarg1;
20438   arg2 = (Dali::Handle::Capability)jarg2;
20439   {
20440     try {
20441       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20442     } catch (std::out_of_range& e) {
20443       {
20444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20445       };
20446     } catch (std::exception& e) {
20447       {
20448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20449       };
20450     } catch (Dali::DaliException e) {
20451       {
20452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20453       };
20454     } catch (...) {
20455       {
20456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20457       };
20458     }
20459   }
20460
20461   jresult = result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20467   unsigned int jresult ;
20468   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20469   unsigned int result;
20470
20471   arg1 = (Dali::Handle *)jarg1;
20472   {
20473     try {
20474       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20475     } catch (std::out_of_range& e) {
20476       {
20477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20478       };
20479     } catch (std::exception& e) {
20480       {
20481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20482       };
20483     } catch (Dali::DaliException e) {
20484       {
20485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20486       };
20487     } catch (...) {
20488       {
20489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20490       };
20491     }
20492   }
20493
20494   jresult = result;
20495   return jresult;
20496 }
20497
20498
20499 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20500   char * jresult ;
20501   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20502   Dali::Property::Index arg2 ;
20503   std::string result;
20504
20505   arg1 = (Dali::Handle *)jarg1;
20506   arg2 = (Dali::Property::Index)jarg2;
20507   {
20508     try {
20509       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20510     } catch (std::out_of_range& e) {
20511       {
20512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20513       };
20514     } catch (std::exception& e) {
20515       {
20516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20517       };
20518     } catch (Dali::DaliException e) {
20519       {
20520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20521       };
20522     } catch (...) {
20523       {
20524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20525       };
20526     }
20527   }
20528
20529   jresult = SWIG_csharp_string_callback((&result)->c_str());
20530   return jresult;
20531 }
20532
20533
20534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20535   int jresult ;
20536   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20537   std::string *arg2 = 0 ;
20538   Dali::Property::Index result;
20539
20540   arg1 = (Dali::Handle *)jarg1;
20541   if (!jarg2) {
20542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20543     return 0;
20544   }
20545   std::string arg2_str(jarg2);
20546   arg2 = &arg2_str;
20547   {
20548     try {
20549       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20550     } catch (std::out_of_range& e) {
20551       {
20552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20553       };
20554     } catch (std::exception& e) {
20555       {
20556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (Dali::DaliException e) {
20559       {
20560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20561       };
20562     } catch (...) {
20563       {
20564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20565       };
20566     }
20567   }
20568
20569   jresult = result;
20570
20571   //argout typemap for const std::string&
20572
20573   return jresult;
20574 }
20575
20576
20577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20578   unsigned int jresult ;
20579   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20580   Dali::Property::Index arg2 ;
20581   bool result;
20582
20583   arg1 = (Dali::Handle *)jarg1;
20584   arg2 = (Dali::Property::Index)jarg2;
20585   {
20586     try {
20587       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20588     } catch (std::out_of_range& e) {
20589       {
20590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20591       };
20592     } catch (std::exception& e) {
20593       {
20594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20595       };
20596     } catch (Dali::DaliException e) {
20597       {
20598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20599       };
20600     } catch (...) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20603       };
20604     }
20605   }
20606
20607   jresult = result;
20608   return jresult;
20609 }
20610
20611
20612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20613   unsigned int jresult ;
20614   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20615   Dali::Property::Index arg2 ;
20616   bool result;
20617
20618   arg1 = (Dali::Handle *)jarg1;
20619   arg2 = (Dali::Property::Index)jarg2;
20620   {
20621     try {
20622       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20623     } catch (std::out_of_range& e) {
20624       {
20625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20626       };
20627     } catch (std::exception& e) {
20628       {
20629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20630       };
20631     } catch (Dali::DaliException e) {
20632       {
20633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20634       };
20635     } catch (...) {
20636       {
20637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20638       };
20639     }
20640   }
20641
20642   jresult = result;
20643   return jresult;
20644 }
20645
20646
20647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20648   unsigned int jresult ;
20649   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20650   Dali::Property::Index arg2 ;
20651   bool result;
20652
20653   arg1 = (Dali::Handle *)jarg1;
20654   arg2 = (Dali::Property::Index)jarg2;
20655   {
20656     try {
20657       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20658     } catch (std::out_of_range& e) {
20659       {
20660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20661       };
20662     } catch (std::exception& e) {
20663       {
20664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20665       };
20666     } catch (Dali::DaliException e) {
20667       {
20668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20669       };
20670     } catch (...) {
20671       {
20672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20673       };
20674     }
20675   }
20676
20677   jresult = result;
20678   return jresult;
20679 }
20680
20681
20682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20683   int jresult ;
20684   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20685   Dali::Property::Index arg2 ;
20686   Dali::Property::Type result;
20687
20688   arg1 = (Dali::Handle *)jarg1;
20689   arg2 = (Dali::Property::Index)jarg2;
20690   {
20691     try {
20692       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (Dali::DaliException e) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711
20712   jresult = (int)result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20718   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20719   Dali::Property::Index arg2 ;
20720   Dali::Property::Value *arg3 = 0 ;
20721
20722   arg1 = (Dali::Handle *)jarg1;
20723   arg2 = (Dali::Property::Index)jarg2;
20724   arg3 = (Dali::Property::Value *)jarg3;
20725   if (!arg3) {
20726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20727     return ;
20728   }
20729   {
20730     try {
20731       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20732     } catch (std::out_of_range& e) {
20733       {
20734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20735       };
20736     } catch (std::exception& e) {
20737       {
20738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20739       };
20740     } catch (Dali::DaliException e) {
20741       {
20742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20743       };
20744     } catch (...) {
20745       {
20746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20747       };
20748     }
20749   }
20750
20751 }
20752
20753
20754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20755   int jresult ;
20756   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20757   std::string *arg2 = 0 ;
20758   Dali::Property::Value *arg3 = 0 ;
20759   Dali::Property::Index result;
20760
20761   arg1 = (Dali::Handle *)jarg1;
20762   if (!jarg2) {
20763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20764     return 0;
20765   }
20766   std::string arg2_str(jarg2);
20767   arg2 = &arg2_str;
20768   arg3 = (Dali::Property::Value *)jarg3;
20769   if (!arg3) {
20770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20771     return 0;
20772   }
20773   {
20774     try {
20775       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20776     } catch (std::out_of_range& e) {
20777       {
20778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (std::exception& e) {
20781       {
20782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20783       };
20784     } catch (Dali::DaliException e) {
20785       {
20786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20787       };
20788     } catch (...) {
20789       {
20790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20791       };
20792     }
20793   }
20794
20795   jresult = result;
20796
20797   //argout typemap for const std::string&
20798
20799   return jresult;
20800 }
20801
20802
20803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20804   int jresult ;
20805   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20806   std::string *arg2 = 0 ;
20807   Dali::Property::Value *arg3 = 0 ;
20808   Dali::Property::AccessMode arg4 ;
20809   Dali::Property::Index result;
20810
20811   arg1 = (Dali::Handle *)jarg1;
20812   if (!jarg2) {
20813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20814     return 0;
20815   }
20816   std::string arg2_str(jarg2);
20817   arg2 = &arg2_str;
20818   arg3 = (Dali::Property::Value *)jarg3;
20819   if (!arg3) {
20820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20821     return 0;
20822   }
20823   arg4 = (Dali::Property::AccessMode)jarg4;
20824   {
20825     try {
20826       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20827     } catch (std::out_of_range& e) {
20828       {
20829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20830       };
20831     } catch (std::exception& e) {
20832       {
20833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20834       };
20835     } catch (Dali::DaliException e) {
20836       {
20837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20838       };
20839     } catch (...) {
20840       {
20841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20842       };
20843     }
20844   }
20845
20846   jresult = result;
20847
20848   //argout typemap for const std::string&
20849
20850   return jresult;
20851 }
20852
20853
20854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20855   void * jresult ;
20856   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20857   Dali::Property::Index arg2 ;
20858   Dali::Property::Value result;
20859
20860   arg1 = (Dali::Handle *)jarg1;
20861   arg2 = (Dali::Property::Index)jarg2;
20862   {
20863     try {
20864       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20865     } catch (std::out_of_range& e) {
20866       {
20867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20868       };
20869     } catch (std::exception& e) {
20870       {
20871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (Dali::DaliException e) {
20874       {
20875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20876       };
20877     } catch (...) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20880       };
20881     }
20882   }
20883
20884   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20885   return jresult;
20886 }
20887
20888
20889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20890   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20891   Dali::Property::IndexContainer *arg2 = 0 ;
20892
20893   arg1 = (Dali::Handle *)jarg1;
20894   arg2 = (Dali::Property::IndexContainer *)jarg2;
20895   if (!arg2) {
20896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20897     return ;
20898   }
20899   {
20900     try {
20901       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20917       };
20918     }
20919   }
20920
20921 }
20922
20923
20924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20925   void * jresult ;
20926   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20927   Dali::Property::Index arg2 ;
20928   Dali::PropertyCondition *arg3 = 0 ;
20929   Dali::PropertyNotification result;
20930
20931   arg1 = (Dali::Handle *)jarg1;
20932   arg2 = (Dali::Property::Index)jarg2;
20933   arg3 = (Dali::PropertyCondition *)jarg3;
20934   if (!arg3) {
20935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20936     return 0;
20937   }
20938   {
20939     try {
20940       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20941     } catch (std::out_of_range& e) {
20942       {
20943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20944       };
20945     } catch (std::exception& e) {
20946       {
20947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20948       };
20949     } catch (Dali::DaliException e) {
20950       {
20951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20952       };
20953     } catch (...) {
20954       {
20955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20956       };
20957     }
20958   }
20959
20960   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20961   return jresult;
20962 }
20963
20964
20965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20966   void * jresult ;
20967   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20968   Dali::Property::Index arg2 ;
20969   int arg3 ;
20970   Dali::PropertyCondition *arg4 = 0 ;
20971   Dali::PropertyNotification result;
20972
20973   arg1 = (Dali::Handle *)jarg1;
20974   arg2 = (Dali::Property::Index)jarg2;
20975   arg3 = (int)jarg3;
20976   arg4 = (Dali::PropertyCondition *)jarg4;
20977   if (!arg4) {
20978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20979     return 0;
20980   }
20981   {
20982     try {
20983       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20984     } catch (std::out_of_range& e) {
20985       {
20986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20987       };
20988     } catch (std::exception& e) {
20989       {
20990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20991       };
20992     } catch (Dali::DaliException e) {
20993       {
20994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20995       };
20996     } catch (...) {
20997       {
20998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20999       };
21000     }
21001   }
21002
21003   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21004   return jresult;
21005 }
21006
21007
21008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21009   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21010   Dali::PropertyNotification arg2 ;
21011   Dali::PropertyNotification *argp2 ;
21012
21013   arg1 = (Dali::Handle *)jarg1;
21014   argp2 = (Dali::PropertyNotification *)jarg2;
21015   if (!argp2) {
21016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21017     return ;
21018   }
21019   arg2 = *argp2;
21020   {
21021     try {
21022       (arg1)->RemovePropertyNotification(arg2);
21023     } catch (std::out_of_range& e) {
21024       {
21025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21026       };
21027     } catch (std::exception& e) {
21028       {
21029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21030       };
21031     } catch (Dali::DaliException e) {
21032       {
21033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21034       };
21035     } catch (...) {
21036       {
21037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21038       };
21039     }
21040   }
21041
21042 }
21043
21044
21045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21047
21048   arg1 = (Dali::Handle *)jarg1;
21049   {
21050     try {
21051       (arg1)->RemovePropertyNotifications();
21052     } catch (std::out_of_range& e) {
21053       {
21054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21055       };
21056     } catch (std::exception& e) {
21057       {
21058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21059       };
21060     } catch (Dali::DaliException e) {
21061       {
21062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21063       };
21064     } catch (...) {
21065       {
21066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21067       };
21068     }
21069   }
21070
21071 }
21072
21073
21074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21075   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21076
21077   arg1 = (Dali::Handle *)jarg1;
21078   {
21079     try {
21080       (arg1)->RemoveConstraints();
21081     } catch (std::out_of_range& e) {
21082       {
21083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21084       };
21085     } catch (std::exception& e) {
21086       {
21087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21088       };
21089     } catch (Dali::DaliException e) {
21090       {
21091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21092       };
21093     } catch (...) {
21094       {
21095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21096       };
21097     }
21098   }
21099
21100 }
21101
21102
21103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21104   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21105   unsigned int arg2 ;
21106
21107   arg1 = (Dali::Handle *)jarg1;
21108   arg2 = (unsigned int)jarg2;
21109   {
21110     try {
21111       (arg1)->RemoveConstraints(arg2);
21112     } catch (std::out_of_range& e) {
21113       {
21114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21115       };
21116     } catch (std::exception& e) {
21117       {
21118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21119       };
21120     } catch (Dali::DaliException e) {
21121       {
21122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21123       };
21124     } catch (...) {
21125       {
21126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21127       };
21128     }
21129   }
21130
21131 }
21132
21133
21134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21135   int jresult ;
21136   Dali::Property::Index result;
21137
21138   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21139   jresult = result;
21140   return jresult;
21141 }
21142
21143
21144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21145   void * jresult ;
21146   Dali::Handle result;
21147
21148   {
21149     try {
21150       result = Dali::WeightObject::New();
21151     } catch (std::out_of_range& e) {
21152       {
21153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21154       };
21155     } catch (std::exception& e) {
21156       {
21157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21158       };
21159     } catch (Dali::DaliException e) {
21160       {
21161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21162       };
21163     } catch (...) {
21164       {
21165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21166       };
21167     }
21168   }
21169
21170   jresult = new Dali::Handle((const Dali::Handle &)result);
21171   return jresult;
21172 }
21173
21174
21175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21176   void * jresult ;
21177   Dali::TypeInfo *result = 0 ;
21178
21179   {
21180     try {
21181       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21182     } catch (std::out_of_range& e) {
21183       {
21184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21185       };
21186     } catch (std::exception& e) {
21187       {
21188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21189       };
21190     } catch (Dali::DaliException e) {
21191       {
21192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21193       };
21194     } catch (...) {
21195       {
21196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21197       };
21198     }
21199   }
21200
21201   jresult = (void *)result;
21202   return jresult;
21203 }
21204
21205
21206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21207   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21208
21209   arg1 = (Dali::TypeInfo *)jarg1;
21210   {
21211     try {
21212       delete arg1;
21213     } catch (std::out_of_range& e) {
21214       {
21215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21216       };
21217     } catch (std::exception& e) {
21218       {
21219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21220       };
21221     } catch (Dali::DaliException e) {
21222       {
21223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21224       };
21225     } catch (...) {
21226       {
21227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21228       };
21229     }
21230   }
21231
21232 }
21233
21234
21235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21236   void * jresult ;
21237   Dali::TypeInfo *arg1 = 0 ;
21238   Dali::TypeInfo *result = 0 ;
21239
21240   arg1 = (Dali::TypeInfo *)jarg1;
21241   if (!arg1) {
21242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21243     return 0;
21244   }
21245   {
21246     try {
21247       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21248     } catch (std::out_of_range& e) {
21249       {
21250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21251       };
21252     } catch (std::exception& e) {
21253       {
21254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (Dali::DaliException e) {
21257       {
21258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21259       };
21260     } catch (...) {
21261       {
21262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21263       };
21264     }
21265   }
21266
21267   jresult = (void *)result;
21268   return jresult;
21269 }
21270
21271
21272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21273   void * jresult ;
21274   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21275   Dali::TypeInfo *arg2 = 0 ;
21276   Dali::TypeInfo *result = 0 ;
21277
21278   arg1 = (Dali::TypeInfo *)jarg1;
21279   arg2 = (Dali::TypeInfo *)jarg2;
21280   if (!arg2) {
21281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21282     return 0;
21283   }
21284   {
21285     try {
21286       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21287     } catch (std::out_of_range& e) {
21288       {
21289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (std::exception& e) {
21292       {
21293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21294       };
21295     } catch (Dali::DaliException e) {
21296       {
21297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21298       };
21299     } catch (...) {
21300       {
21301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21302       };
21303     }
21304   }
21305
21306   jresult = (void *)result;
21307   return jresult;
21308 }
21309
21310
21311 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21312   char * jresult ;
21313   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21314   std::string *result = 0 ;
21315
21316   arg1 = (Dali::TypeInfo *)jarg1;
21317   {
21318     try {
21319       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21320     } catch (std::out_of_range& e) {
21321       {
21322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21323       };
21324     } catch (std::exception& e) {
21325       {
21326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21327       };
21328     } catch (Dali::DaliException e) {
21329       {
21330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21331       };
21332     } catch (...) {
21333       {
21334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21335       };
21336     }
21337   }
21338
21339   jresult = SWIG_csharp_string_callback(result->c_str());
21340   return jresult;
21341 }
21342
21343
21344 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21345   char * jresult ;
21346   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21347   std::string *result = 0 ;
21348
21349   arg1 = (Dali::TypeInfo *)jarg1;
21350   {
21351     try {
21352       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21353     } catch (std::out_of_range& e) {
21354       {
21355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21356       };
21357     } catch (std::exception& e) {
21358       {
21359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (Dali::DaliException e) {
21362       {
21363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21364       };
21365     } catch (...) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21368       };
21369     }
21370   }
21371
21372   jresult = SWIG_csharp_string_callback(result->c_str());
21373   return jresult;
21374 }
21375
21376
21377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21378   void * jresult ;
21379   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21380   Dali::BaseHandle result;
21381
21382   arg1 = (Dali::TypeInfo *)jarg1;
21383   {
21384     try {
21385       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21386     } catch (std::out_of_range& e) {
21387       {
21388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21389       };
21390     } catch (std::exception& e) {
21391       {
21392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21393       };
21394     } catch (Dali::DaliException e) {
21395       {
21396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21397       };
21398     } catch (...) {
21399       {
21400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21401       };
21402     }
21403   }
21404
21405   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21406   return jresult;
21407 }
21408
21409
21410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21411   unsigned long jresult ;
21412   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21413   size_t result;
21414
21415   arg1 = (Dali::TypeInfo *)jarg1;
21416   {
21417     try {
21418       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21419     } catch (std::out_of_range& e) {
21420       {
21421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21422       };
21423     } catch (std::exception& e) {
21424       {
21425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21426       };
21427     } catch (Dali::DaliException e) {
21428       {
21429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21430       };
21431     } catch (...) {
21432       {
21433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21434       };
21435     }
21436   }
21437
21438   jresult = (unsigned long)result;
21439   return jresult;
21440 }
21441
21442
21443 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21444   char * jresult ;
21445   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21446   size_t arg2 ;
21447   std::string result;
21448
21449   arg1 = (Dali::TypeInfo *)jarg1;
21450   arg2 = (size_t)jarg2;
21451   {
21452     try {
21453       result = (arg1)->GetActionName(arg2);
21454     } catch (std::out_of_range& e) {
21455       {
21456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21457       };
21458     } catch (std::exception& e) {
21459       {
21460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21461       };
21462     } catch (Dali::DaliException e) {
21463       {
21464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21465       };
21466     } catch (...) {
21467       {
21468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21469       };
21470     }
21471   }
21472
21473   jresult = SWIG_csharp_string_callback((&result)->c_str());
21474   return jresult;
21475 }
21476
21477
21478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21479   unsigned long jresult ;
21480   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21481   size_t result;
21482
21483   arg1 = (Dali::TypeInfo *)jarg1;
21484   {
21485     try {
21486       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21487     } catch (std::out_of_range& e) {
21488       {
21489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (std::exception& e) {
21492       {
21493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (Dali::DaliException e) {
21496       {
21497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21498       };
21499     } catch (...) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21502       };
21503     }
21504   }
21505
21506   jresult = (unsigned long)result;
21507   return jresult;
21508 }
21509
21510
21511 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21512   char * jresult ;
21513   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21514   size_t arg2 ;
21515   std::string result;
21516
21517   arg1 = (Dali::TypeInfo *)jarg1;
21518   arg2 = (size_t)jarg2;
21519   {
21520     try {
21521       result = (arg1)->GetSignalName(arg2);
21522     } catch (std::out_of_range& e) {
21523       {
21524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21525       };
21526     } catch (std::exception& e) {
21527       {
21528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21529       };
21530     } catch (Dali::DaliException e) {
21531       {
21532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21533       };
21534     } catch (...) {
21535       {
21536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21537       };
21538     }
21539   }
21540
21541   jresult = SWIG_csharp_string_callback((&result)->c_str());
21542   return jresult;
21543 }
21544
21545
21546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21547   unsigned long jresult ;
21548   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21549   size_t result;
21550
21551   arg1 = (Dali::TypeInfo *)jarg1;
21552   {
21553     try {
21554       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21555     } catch (std::out_of_range& e) {
21556       {
21557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21558       };
21559     } catch (std::exception& e) {
21560       {
21561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21562       };
21563     } catch (Dali::DaliException e) {
21564       {
21565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21566       };
21567     } catch (...) {
21568       {
21569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21570       };
21571     }
21572   }
21573
21574   jresult = (unsigned long)result;
21575   return jresult;
21576 }
21577
21578
21579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21580   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21581   Dali::Property::IndexContainer *arg2 = 0 ;
21582
21583   arg1 = (Dali::TypeInfo *)jarg1;
21584   arg2 = (Dali::Property::IndexContainer *)jarg2;
21585   if (!arg2) {
21586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21587     return ;
21588   }
21589   {
21590     try {
21591       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21592     } catch (std::out_of_range& e) {
21593       {
21594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21595       };
21596     } catch (std::exception& e) {
21597       {
21598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21599       };
21600     } catch (Dali::DaliException e) {
21601       {
21602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21603       };
21604     } catch (...) {
21605       {
21606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21607       };
21608     }
21609   }
21610
21611 }
21612
21613
21614 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21615   char * jresult ;
21616   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21617   Dali::Property::Index arg2 ;
21618   std::string *result = 0 ;
21619
21620   arg1 = (Dali::TypeInfo *)jarg1;
21621   arg2 = (Dali::Property::Index)jarg2;
21622   {
21623     try {
21624       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21625     } catch (std::out_of_range& e) {
21626       {
21627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21628       };
21629     } catch (std::exception& e) {
21630       {
21631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21632       };
21633     } catch (Dali::DaliException e) {
21634       {
21635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21636       };
21637     } catch (...) {
21638       {
21639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21640       };
21641     }
21642   }
21643
21644   jresult = SWIG_csharp_string_callback(result->c_str());
21645   return jresult;
21646 }
21647
21648
21649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21650   void * jresult ;
21651   Dali::TypeRegistry result;
21652
21653   {
21654     try {
21655       result = Dali::TypeRegistry::Get();
21656     } catch (std::out_of_range& e) {
21657       {
21658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21659       };
21660     } catch (std::exception& e) {
21661       {
21662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21663       };
21664     } catch (Dali::DaliException e) {
21665       {
21666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21667       };
21668     } catch (...) {
21669       {
21670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21671       };
21672     }
21673   }
21674
21675   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21676   return jresult;
21677 }
21678
21679
21680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21681   void * jresult ;
21682   Dali::TypeRegistry *result = 0 ;
21683
21684   {
21685     try {
21686       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21687     } catch (std::out_of_range& e) {
21688       {
21689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21690       };
21691     } catch (std::exception& e) {
21692       {
21693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21694       };
21695     } catch (Dali::DaliException e) {
21696       {
21697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21698       };
21699     } catch (...) {
21700       {
21701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21702       };
21703     }
21704   }
21705
21706   jresult = (void *)result;
21707   return jresult;
21708 }
21709
21710
21711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21712   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21713
21714   arg1 = (Dali::TypeRegistry *)jarg1;
21715   {
21716     try {
21717       delete arg1;
21718     } catch (std::out_of_range& e) {
21719       {
21720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21721       };
21722     } catch (std::exception& e) {
21723       {
21724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21725       };
21726     } catch (Dali::DaliException e) {
21727       {
21728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21729       };
21730     } catch (...) {
21731       {
21732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21733       };
21734     }
21735   }
21736
21737 }
21738
21739
21740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21741   void * jresult ;
21742   Dali::TypeRegistry *arg1 = 0 ;
21743   Dali::TypeRegistry *result = 0 ;
21744
21745   arg1 = (Dali::TypeRegistry *)jarg1;
21746   if (!arg1) {
21747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21748     return 0;
21749   }
21750   {
21751     try {
21752       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21753     } catch (std::out_of_range& e) {
21754       {
21755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21756       };
21757     } catch (std::exception& e) {
21758       {
21759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (Dali::DaliException e) {
21762       {
21763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21764       };
21765     } catch (...) {
21766       {
21767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21768       };
21769     }
21770   }
21771
21772   jresult = (void *)result;
21773   return jresult;
21774 }
21775
21776
21777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21778   void * jresult ;
21779   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21780   Dali::TypeRegistry *arg2 = 0 ;
21781   Dali::TypeRegistry *result = 0 ;
21782
21783   arg1 = (Dali::TypeRegistry *)jarg1;
21784   arg2 = (Dali::TypeRegistry *)jarg2;
21785   if (!arg2) {
21786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21787     return 0;
21788   }
21789   {
21790     try {
21791       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21792     } catch (std::out_of_range& e) {
21793       {
21794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21795       };
21796     } catch (std::exception& e) {
21797       {
21798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (Dali::DaliException e) {
21801       {
21802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21803       };
21804     } catch (...) {
21805       {
21806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21807       };
21808     }
21809   }
21810
21811   jresult = (void *)result;
21812   return jresult;
21813 }
21814
21815
21816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21817   void * jresult ;
21818   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21819   std::string *arg2 = 0 ;
21820   Dali::TypeInfo result;
21821
21822   arg1 = (Dali::TypeRegistry *)jarg1;
21823   if (!jarg2) {
21824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21825     return 0;
21826   }
21827   std::string arg2_str(jarg2);
21828   arg2 = &arg2_str;
21829   {
21830     try {
21831       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21832     } catch (std::out_of_range& e) {
21833       {
21834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21835       };
21836     } catch (std::exception& e) {
21837       {
21838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21839       };
21840     } catch (Dali::DaliException e) {
21841       {
21842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21843       };
21844     } catch (...) {
21845       {
21846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21847       };
21848     }
21849   }
21850
21851   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21852
21853   //argout typemap for const std::string&
21854
21855   return jresult;
21856 }
21857
21858
21859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21860   void * jresult ;
21861   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21862   std::type_info *arg2 = 0 ;
21863   Dali::TypeInfo result;
21864
21865   arg1 = (Dali::TypeRegistry *)jarg1;
21866   arg2 = (std::type_info *)jarg2;
21867   if (!arg2) {
21868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21869     return 0;
21870   }
21871   {
21872     try {
21873       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21874     } catch (std::out_of_range& e) {
21875       {
21876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21877       };
21878     } catch (std::exception& e) {
21879       {
21880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21881       };
21882     } catch (Dali::DaliException e) {
21883       {
21884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21885       };
21886     } catch (...) {
21887       {
21888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21889       };
21890     }
21891   }
21892
21893   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21894   return jresult;
21895 }
21896
21897
21898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21899   unsigned long jresult ;
21900   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21901   size_t result;
21902
21903   arg1 = (Dali::TypeRegistry *)jarg1;
21904   {
21905     try {
21906       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21907     } catch (std::out_of_range& e) {
21908       {
21909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (std::exception& e) {
21912       {
21913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (Dali::DaliException e) {
21916       {
21917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21918       };
21919     } catch (...) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21922       };
21923     }
21924   }
21925
21926   jresult = (unsigned long)result;
21927   return jresult;
21928 }
21929
21930
21931 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21932   char * jresult ;
21933   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21934   size_t arg2 ;
21935   std::string result;
21936
21937   arg1 = (Dali::TypeRegistry *)jarg1;
21938   arg2 = (size_t)jarg2;
21939   {
21940     try {
21941       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21942     } catch (std::out_of_range& e) {
21943       {
21944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21945       };
21946     } catch (std::exception& e) {
21947       {
21948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21949       };
21950     } catch (Dali::DaliException e) {
21951       {
21952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21953       };
21954     } catch (...) {
21955       {
21956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21957       };
21958     }
21959   }
21960
21961   jresult = SWIG_csharp_string_callback((&result)->c_str());
21962   return jresult;
21963 }
21964
21965
21966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21967   void * jresult ;
21968   std::type_info *arg1 = 0 ;
21969   std::type_info *arg2 = 0 ;
21970   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21971   Dali::TypeRegistration *result = 0 ;
21972
21973   arg1 = (std::type_info *)jarg1;
21974   if (!arg1) {
21975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21976     return 0;
21977   }
21978   arg2 = (std::type_info *)jarg2;
21979   if (!arg2) {
21980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21981     return 0;
21982   }
21983   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21984   {
21985     try {
21986       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21987     } catch (std::out_of_range& e) {
21988       {
21989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21990       };
21991     } catch (std::exception& e) {
21992       {
21993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21994       };
21995     } catch (Dali::DaliException e) {
21996       {
21997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21998       };
21999     } catch (...) {
22000       {
22001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22002       };
22003     }
22004   }
22005
22006   jresult = (void *)result;
22007   return jresult;
22008 }
22009
22010
22011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22012   void * jresult ;
22013   std::type_info *arg1 = 0 ;
22014   std::type_info *arg2 = 0 ;
22015   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22016   bool arg4 ;
22017   Dali::TypeRegistration *result = 0 ;
22018
22019   arg1 = (std::type_info *)jarg1;
22020   if (!arg1) {
22021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22022     return 0;
22023   }
22024   arg2 = (std::type_info *)jarg2;
22025   if (!arg2) {
22026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22027     return 0;
22028   }
22029   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22030   arg4 = jarg4 ? true : false;
22031   {
22032     try {
22033       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22034     } catch (std::out_of_range& e) {
22035       {
22036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22037       };
22038     } catch (std::exception& e) {
22039       {
22040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22041       };
22042     } catch (Dali::DaliException e) {
22043       {
22044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22045       };
22046     } catch (...) {
22047       {
22048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22049       };
22050     }
22051   }
22052
22053   jresult = (void *)result;
22054   return jresult;
22055 }
22056
22057
22058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22059   void * jresult ;
22060   std::string *arg1 = 0 ;
22061   std::type_info *arg2 = 0 ;
22062   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22063   Dali::TypeRegistration *result = 0 ;
22064
22065   if (!jarg1) {
22066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22067     return 0;
22068   }
22069   std::string arg1_str(jarg1);
22070   arg1 = &arg1_str;
22071   arg2 = (std::type_info *)jarg2;
22072   if (!arg2) {
22073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22074     return 0;
22075   }
22076   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22077   {
22078     try {
22079       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22080     } catch (std::out_of_range& e) {
22081       {
22082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22083       };
22084     } catch (std::exception& e) {
22085       {
22086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22087       };
22088     } catch (Dali::DaliException e) {
22089       {
22090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22091       };
22092     } catch (...) {
22093       {
22094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22095       };
22096     }
22097   }
22098
22099   jresult = (void *)result;
22100
22101   //argout typemap for const std::string&
22102
22103   return jresult;
22104 }
22105
22106
22107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22108   char * jresult ;
22109   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22110   std::string result;
22111
22112   arg1 = (Dali::TypeRegistration *)jarg1;
22113   {
22114     try {
22115       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22116     } catch (std::out_of_range& e) {
22117       {
22118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22119       };
22120     } catch (std::exception& e) {
22121       {
22122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22123       };
22124     } catch (Dali::DaliException e) {
22125       {
22126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22127       };
22128     } catch (...) {
22129       {
22130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22131       };
22132     }
22133   }
22134
22135   jresult = SWIG_csharp_string_callback((&result)->c_str());
22136   return jresult;
22137 }
22138
22139
22140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22141   std::string *arg1 = 0 ;
22142   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22143
22144   if (!jarg1) {
22145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22146     return ;
22147   }
22148   std::string arg1_str(jarg1);
22149   arg1 = &arg1_str;
22150   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22151   {
22152     try {
22153       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22154     } catch (std::out_of_range& e) {
22155       {
22156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22157       };
22158     } catch (std::exception& e) {
22159       {
22160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22161       };
22162     } catch (Dali::DaliException e) {
22163       {
22164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22165       };
22166     } catch (...) {
22167       {
22168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22169       };
22170     }
22171   }
22172
22173
22174   //argout typemap for const std::string&
22175
22176 }
22177
22178
22179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22180   std::string *arg1 = 0 ;
22181   std::string *arg2 = 0 ;
22182   int arg3 ;
22183   Dali::Property::Type arg4 ;
22184   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22185   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22186
22187   if (!jarg1) {
22188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22189     return ;
22190   }
22191   std::string arg1_str(jarg1);
22192   arg1 = &arg1_str;
22193   if (!jarg2) {
22194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22195     return ;
22196   }
22197   std::string arg2_str(jarg2);
22198   arg2 = &arg2_str;
22199   arg3 = (int)jarg3;
22200   arg4 = (Dali::Property::Type)jarg4;
22201   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22202   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22203   {
22204     try {
22205       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22206     } catch (std::out_of_range& e) {
22207       {
22208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22209       };
22210     } catch (std::exception& e) {
22211       {
22212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22213       };
22214     } catch (Dali::DaliException e) {
22215       {
22216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22217       };
22218     } catch (...) {
22219       {
22220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22221       };
22222     }
22223   }
22224
22225
22226   //argout typemap for const std::string&
22227
22228
22229   //argout typemap for const std::string&
22230
22231 }
22232
22233
22234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22235   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22236
22237   arg1 = (Dali::TypeRegistration *)jarg1;
22238   {
22239     try {
22240       delete arg1;
22241     } catch (std::out_of_range& e) {
22242       {
22243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22244       };
22245     } catch (std::exception& e) {
22246       {
22247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22248       };
22249     } catch (Dali::DaliException e) {
22250       {
22251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22252       };
22253     } catch (...) {
22254       {
22255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22256       };
22257     }
22258   }
22259
22260 }
22261
22262
22263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22264   void * jresult ;
22265   Dali::TypeRegistration *arg1 = 0 ;
22266   std::string *arg2 = 0 ;
22267   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22268   Dali::SignalConnectorType *result = 0 ;
22269
22270   arg1 = (Dali::TypeRegistration *)jarg1;
22271   if (!arg1) {
22272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22273     return 0;
22274   }
22275   if (!jarg2) {
22276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22277     return 0;
22278   }
22279   std::string arg2_str(jarg2);
22280   arg2 = &arg2_str;
22281   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22282   {
22283     try {
22284       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22285     } catch (std::out_of_range& e) {
22286       {
22287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22288       };
22289     } catch (std::exception& e) {
22290       {
22291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22292       };
22293     } catch (Dali::DaliException e) {
22294       {
22295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22296       };
22297     } catch (...) {
22298       {
22299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22300       };
22301     }
22302   }
22303
22304   jresult = (void *)result;
22305
22306   //argout typemap for const std::string&
22307
22308   return jresult;
22309 }
22310
22311
22312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22313   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22314
22315   arg1 = (Dali::SignalConnectorType *)jarg1;
22316   {
22317     try {
22318       delete arg1;
22319     } catch (std::out_of_range& e) {
22320       {
22321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22322       };
22323     } catch (std::exception& e) {
22324       {
22325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22326       };
22327     } catch (Dali::DaliException e) {
22328       {
22329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22330       };
22331     } catch (...) {
22332       {
22333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22334       };
22335     }
22336   }
22337
22338 }
22339
22340
22341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22342   void * jresult ;
22343   Dali::TypeRegistration *arg1 = 0 ;
22344   std::string *arg2 = 0 ;
22345   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22346   Dali::TypeAction *result = 0 ;
22347
22348   arg1 = (Dali::TypeRegistration *)jarg1;
22349   if (!arg1) {
22350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22351     return 0;
22352   }
22353   if (!jarg2) {
22354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22355     return 0;
22356   }
22357   std::string arg2_str(jarg2);
22358   arg2 = &arg2_str;
22359   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22360   {
22361     try {
22362       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22363     } catch (std::out_of_range& e) {
22364       {
22365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22366       };
22367     } catch (std::exception& e) {
22368       {
22369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22370       };
22371     } catch (Dali::DaliException e) {
22372       {
22373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22374       };
22375     } catch (...) {
22376       {
22377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22378       };
22379     }
22380   }
22381
22382   jresult = (void *)result;
22383
22384   //argout typemap for const std::string&
22385
22386   return jresult;
22387 }
22388
22389
22390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22391   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22392
22393   arg1 = (Dali::TypeAction *)jarg1;
22394   {
22395     try {
22396       delete arg1;
22397     } catch (std::out_of_range& e) {
22398       {
22399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22400       };
22401     } catch (std::exception& e) {
22402       {
22403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22404       };
22405     } catch (Dali::DaliException e) {
22406       {
22407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22408       };
22409     } catch (...) {
22410       {
22411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22412       };
22413     }
22414   }
22415
22416 }
22417
22418
22419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22420   void * jresult ;
22421   Dali::TypeRegistration *arg1 = 0 ;
22422   std::string *arg2 = 0 ;
22423   Dali::Property::Index arg3 ;
22424   Dali::Property::Type arg4 ;
22425   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22426   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22427   Dali::PropertyRegistration *result = 0 ;
22428
22429   arg1 = (Dali::TypeRegistration *)jarg1;
22430   if (!arg1) {
22431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22432     return 0;
22433   }
22434   if (!jarg2) {
22435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22436     return 0;
22437   }
22438   std::string arg2_str(jarg2);
22439   arg2 = &arg2_str;
22440   arg3 = (Dali::Property::Index)jarg3;
22441   arg4 = (Dali::Property::Type)jarg4;
22442   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22443   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22444   {
22445     try {
22446       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22447     } catch (std::out_of_range& e) {
22448       {
22449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22450       };
22451     } catch (std::exception& e) {
22452       {
22453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (Dali::DaliException e) {
22456       {
22457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22458       };
22459     } catch (...) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22462       };
22463     }
22464   }
22465
22466   jresult = (void *)result;
22467
22468   //argout typemap for const std::string&
22469
22470   return jresult;
22471 }
22472
22473
22474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22475   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22476
22477   arg1 = (Dali::PropertyRegistration *)jarg1;
22478   {
22479     try {
22480       delete arg1;
22481     } catch (std::out_of_range& e) {
22482       {
22483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22484       };
22485     } catch (std::exception& e) {
22486       {
22487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22488       };
22489     } catch (Dali::DaliException e) {
22490       {
22491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22492       };
22493     } catch (...) {
22494       {
22495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22496       };
22497     }
22498   }
22499
22500 }
22501
22502
22503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22504   void * jresult ;
22505   Dali::TypeRegistration *arg1 = 0 ;
22506   std::string *arg2 = 0 ;
22507   Dali::Property::Index arg3 ;
22508   Dali::Property::Type arg4 ;
22509   Dali::AnimatablePropertyRegistration *result = 0 ;
22510
22511   arg1 = (Dali::TypeRegistration *)jarg1;
22512   if (!arg1) {
22513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22514     return 0;
22515   }
22516   if (!jarg2) {
22517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22518     return 0;
22519   }
22520   std::string arg2_str(jarg2);
22521   arg2 = &arg2_str;
22522   arg3 = (Dali::Property::Index)jarg3;
22523   arg4 = (Dali::Property::Type)jarg4;
22524   {
22525     try {
22526       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22527     } catch (std::out_of_range& e) {
22528       {
22529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22530       };
22531     } catch (std::exception& e) {
22532       {
22533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22534       };
22535     } catch (Dali::DaliException e) {
22536       {
22537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22538       };
22539     } catch (...) {
22540       {
22541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22542       };
22543     }
22544   }
22545
22546   jresult = (void *)result;
22547
22548   //argout typemap for const std::string&
22549
22550   return jresult;
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22555   void * jresult ;
22556   Dali::TypeRegistration *arg1 = 0 ;
22557   std::string *arg2 = 0 ;
22558   Dali::Property::Index arg3 ;
22559   Dali::Property::Value *arg4 = 0 ;
22560   Dali::AnimatablePropertyRegistration *result = 0 ;
22561
22562   arg1 = (Dali::TypeRegistration *)jarg1;
22563   if (!arg1) {
22564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22565     return 0;
22566   }
22567   if (!jarg2) {
22568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22569     return 0;
22570   }
22571   std::string arg2_str(jarg2);
22572   arg2 = &arg2_str;
22573   arg3 = (Dali::Property::Index)jarg3;
22574   arg4 = (Dali::Property::Value *)jarg4;
22575   if (!arg4) {
22576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22577     return 0;
22578   }
22579   {
22580     try {
22581       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22582     } catch (std::out_of_range& e) {
22583       {
22584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22585       };
22586     } catch (std::exception& e) {
22587       {
22588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22589       };
22590     } catch (Dali::DaliException e) {
22591       {
22592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22593       };
22594     } catch (...) {
22595       {
22596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22597       };
22598     }
22599   }
22600
22601   jresult = (void *)result;
22602
22603   //argout typemap for const std::string&
22604
22605   return jresult;
22606 }
22607
22608
22609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22610   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22611
22612   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22613   {
22614     try {
22615       delete arg1;
22616     } catch (std::out_of_range& e) {
22617       {
22618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22619       };
22620     } catch (std::exception& e) {
22621       {
22622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22623       };
22624     } catch (Dali::DaliException e) {
22625       {
22626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22627       };
22628     } catch (...) {
22629       {
22630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22631       };
22632     }
22633   }
22634
22635 }
22636
22637
22638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22639   void * jresult ;
22640   Dali::TypeRegistration *arg1 = 0 ;
22641   std::string *arg2 = 0 ;
22642   Dali::Property::Index arg3 ;
22643   Dali::Property::Index arg4 ;
22644   unsigned int arg5 ;
22645   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22646
22647   arg1 = (Dali::TypeRegistration *)jarg1;
22648   if (!arg1) {
22649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22650     return 0;
22651   }
22652   if (!jarg2) {
22653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22654     return 0;
22655   }
22656   std::string arg2_str(jarg2);
22657   arg2 = &arg2_str;
22658   arg3 = (Dali::Property::Index)jarg3;
22659   arg4 = (Dali::Property::Index)jarg4;
22660   arg5 = (unsigned int)jarg5;
22661   {
22662     try {
22663       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22664     } catch (std::out_of_range& e) {
22665       {
22666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22667       };
22668     } catch (std::exception& e) {
22669       {
22670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22671       };
22672     } catch (Dali::DaliException e) {
22673       {
22674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22675       };
22676     } catch (...) {
22677       {
22678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22679       };
22680     }
22681   }
22682
22683   jresult = (void *)result;
22684
22685   //argout typemap for const std::string&
22686
22687   return jresult;
22688 }
22689
22690
22691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22692   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22693
22694   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22695   {
22696     try {
22697       delete arg1;
22698     } catch (std::out_of_range& e) {
22699       {
22700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22701       };
22702     } catch (std::exception& e) {
22703       {
22704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22705       };
22706     } catch (Dali::DaliException e) {
22707       {
22708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22709       };
22710     } catch (...) {
22711       {
22712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22713       };
22714     }
22715   }
22716
22717 }
22718
22719
22720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22721   void * jresult ;
22722   Dali::TypeRegistration *arg1 = 0 ;
22723   std::string *arg2 = 0 ;
22724   Dali::Property::Index arg3 ;
22725   Dali::Property::Type arg4 ;
22726   Dali::ChildPropertyRegistration *result = 0 ;
22727
22728   arg1 = (Dali::TypeRegistration *)jarg1;
22729   if (!arg1) {
22730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22731     return 0;
22732   }
22733   if (!jarg2) {
22734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22735     return 0;
22736   }
22737   std::string arg2_str(jarg2);
22738   arg2 = &arg2_str;
22739   arg3 = (Dali::Property::Index)jarg3;
22740   arg4 = (Dali::Property::Type)jarg4;
22741   {
22742     try {
22743       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22744     } catch (std::out_of_range& e) {
22745       {
22746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22747       };
22748     } catch (std::exception& e) {
22749       {
22750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22751       };
22752     } catch (Dali::DaliException e) {
22753       {
22754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22755       };
22756     } catch (...) {
22757       {
22758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22759       };
22760     }
22761   }
22762
22763   jresult = (void *)result;
22764
22765   //argout typemap for const std::string&
22766
22767   return jresult;
22768 }
22769
22770
22771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22772   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22773
22774   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22775   {
22776     try {
22777       delete arg1;
22778     } catch (std::out_of_range& e) {
22779       {
22780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22781       };
22782     } catch (std::exception& e) {
22783       {
22784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22785       };
22786     } catch (Dali::DaliException e) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22789       };
22790     } catch (...) {
22791       {
22792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22793       };
22794     }
22795   }
22796
22797 }
22798
22799
22800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22801   unsigned int jresult ;
22802   std::string *arg1 = 0 ;
22803   std::type_info *arg2 = 0 ;
22804   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22805   bool result;
22806
22807   if (!jarg1) {
22808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22809     return 0;
22810   }
22811   std::string arg1_str(jarg1);
22812   arg1 = &arg1_str;
22813   arg2 = (std::type_info *)jarg2;
22814   if (!arg2) {
22815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22816     return 0;
22817   }
22818   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22819   {
22820     try {
22821       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22822     } catch (std::out_of_range& e) {
22823       {
22824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22825       };
22826     } catch (std::exception& e) {
22827       {
22828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22829       };
22830     } catch (Dali::DaliException e) {
22831       {
22832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22833       };
22834     } catch (...) {
22835       {
22836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22837       };
22838     }
22839   }
22840
22841   jresult = result;
22842
22843   //argout typemap for const std::string&
22844
22845   return jresult;
22846 }
22847
22848
22849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22850   unsigned int jresult ;
22851   std::string *arg1 = 0 ;
22852   std::string *arg2 = 0 ;
22853   Dali::Property::Index arg3 ;
22854   Dali::Property::Type arg4 ;
22855   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22856   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22857   bool result;
22858
22859   if (!jarg1) {
22860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22861     return 0;
22862   }
22863   std::string arg1_str(jarg1);
22864   arg1 = &arg1_str;
22865   if (!jarg2) {
22866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22867     return 0;
22868   }
22869   std::string arg2_str(jarg2);
22870   arg2 = &arg2_str;
22871   arg3 = (Dali::Property::Index)jarg3;
22872   arg4 = (Dali::Property::Type)jarg4;
22873   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22874   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22875   {
22876     try {
22877       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22878     } catch (std::out_of_range& e) {
22879       {
22880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22881       };
22882     } catch (std::exception& e) {
22883       {
22884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22885       };
22886     } catch (Dali::DaliException e) {
22887       {
22888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22889       };
22890     } catch (...) {
22891       {
22892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22893       };
22894     }
22895   }
22896
22897   jresult = result;
22898
22899   //argout typemap for const std::string&
22900
22901
22902   //argout typemap for const std::string&
22903
22904   return jresult;
22905 }
22906
22907
22908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22909   float jresult ;
22910   float result;
22911
22912   result = (float)(float)Dali::ParentOrigin::TOP;
22913   jresult = result;
22914   return jresult;
22915 }
22916
22917
22918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22919   float jresult ;
22920   float result;
22921
22922   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22923   jresult = result;
22924   return jresult;
22925 }
22926
22927
22928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22929   float jresult ;
22930   float result;
22931
22932   result = (float)(float)Dali::ParentOrigin::LEFT;
22933   jresult = result;
22934   return jresult;
22935 }
22936
22937
22938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22939   float jresult ;
22940   float result;
22941
22942   result = (float)(float)Dali::ParentOrigin::RIGHT;
22943   jresult = result;
22944   return jresult;
22945 }
22946
22947
22948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22949   float jresult ;
22950   float result;
22951
22952   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22953   jresult = result;
22954   return jresult;
22955 }
22956
22957
22958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22959   void * jresult ;
22960   Dali::Vector3 *result = 0 ;
22961
22962   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22963   jresult = (void *)result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22969   void * jresult ;
22970   Dali::Vector3 *result = 0 ;
22971
22972   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22973   jresult = (void *)result;
22974   return jresult;
22975 }
22976
22977
22978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22979   void * jresult ;
22980   Dali::Vector3 *result = 0 ;
22981
22982   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22983   jresult = (void *)result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22989   void * jresult ;
22990   Dali::Vector3 *result = 0 ;
22991
22992   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22993   jresult = (void *)result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22999   void * jresult ;
23000   Dali::Vector3 *result = 0 ;
23001
23002   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23003   jresult = (void *)result;
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23009   void * jresult ;
23010   Dali::Vector3 *result = 0 ;
23011
23012   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23013   jresult = (void *)result;
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23019   void * jresult ;
23020   Dali::Vector3 *result = 0 ;
23021
23022   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23029   void * jresult ;
23030   Dali::Vector3 *result = 0 ;
23031
23032   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23033   jresult = (void *)result;
23034   return jresult;
23035 }
23036
23037
23038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23039   void * jresult ;
23040   Dali::Vector3 *result = 0 ;
23041
23042   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23043   jresult = (void *)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23049   float jresult ;
23050   float result;
23051
23052   result = (float)(float)Dali::AnchorPoint::TOP;
23053   jresult = result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23059   float jresult ;
23060   float result;
23061
23062   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23063   jresult = result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23069   float jresult ;
23070   float result;
23071
23072   result = (float)(float)Dali::AnchorPoint::LEFT;
23073   jresult = result;
23074   return jresult;
23075 }
23076
23077
23078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23079   float jresult ;
23080   float result;
23081
23082   result = (float)(float)Dali::AnchorPoint::RIGHT;
23083   jresult = result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23089   float jresult ;
23090   float result;
23091
23092   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23093   jresult = result;
23094   return jresult;
23095 }
23096
23097
23098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23099   void * jresult ;
23100   Dali::Vector3 *result = 0 ;
23101
23102   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23103   jresult = (void *)result;
23104   return jresult;
23105 }
23106
23107
23108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23109   void * jresult ;
23110   Dali::Vector3 *result = 0 ;
23111
23112   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23113   jresult = (void *)result;
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23119   void * jresult ;
23120   Dali::Vector3 *result = 0 ;
23121
23122   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23123   jresult = (void *)result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23129   void * jresult ;
23130   Dali::Vector3 *result = 0 ;
23131
23132   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23133   jresult = (void *)result;
23134   return jresult;
23135 }
23136
23137
23138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23139   void * jresult ;
23140   Dali::Vector3 *result = 0 ;
23141
23142   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23143   jresult = (void *)result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23149   void * jresult ;
23150   Dali::Vector3 *result = 0 ;
23151
23152   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23153   jresult = (void *)result;
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23159   void * jresult ;
23160   Dali::Vector3 *result = 0 ;
23161
23162   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23163   jresult = (void *)result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23169   void * jresult ;
23170   Dali::Vector3 *result = 0 ;
23171
23172   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23173   jresult = (void *)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23179   void * jresult ;
23180   Dali::Vector3 *result = 0 ;
23181
23182   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23183   jresult = (void *)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23189   void * jresult ;
23190   Dali::Vector4 *result = 0 ;
23191
23192   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23193   jresult = (void *)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23199   void * jresult ;
23200   Dali::Vector4 *result = 0 ;
23201
23202   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23203   jresult = (void *)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23209   void * jresult ;
23210   Dali::Vector4 *result = 0 ;
23211
23212   result = (Dali::Vector4 *)&Dali::Color::RED;
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23219   void * jresult ;
23220   Dali::Vector4 *result = 0 ;
23221
23222   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23229   void * jresult ;
23230   Dali::Vector4 *result = 0 ;
23231
23232   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23233   jresult = (void *)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23239   void * jresult ;
23240   Dali::Vector4 *result = 0 ;
23241
23242   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23249   void * jresult ;
23250   Dali::Vector4 *result = 0 ;
23251
23252   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23253   jresult = (void *)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23259   void * jresult ;
23260   Dali::Vector4 *result = 0 ;
23261
23262   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23269   void * jresult ;
23270   Dali::Vector4 *result = 0 ;
23271
23272   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23279   float jresult ;
23280   float result;
23281
23282   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23283   jresult = result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23289   float jresult ;
23290   float result;
23291
23292   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23293   jresult = result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23299   float jresult ;
23300   float result;
23301
23302   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23303   jresult = result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23309   float jresult ;
23310   float result;
23311
23312   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23313   jresult = result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23319   float jresult ;
23320   float result;
23321
23322   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23323   jresult = result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23329   float jresult ;
23330   float result;
23331
23332   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23333   jresult = result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23339   float jresult ;
23340   float result;
23341
23342   result = (float)(float)Dali::Math::PI;
23343   jresult = result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23349   float jresult ;
23350   float result;
23351
23352   result = (float)(float)Dali::Math::PI_2;
23353   jresult = result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23359   float jresult ;
23360   float result;
23361
23362   result = (float)(float)Dali::Math::PI_4;
23363   jresult = result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23369   float jresult ;
23370   float result;
23371
23372   result = (float)(float)Dali::Math::PI_OVER_180;
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23379   float jresult ;
23380   float result;
23381
23382   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23383   jresult = result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23389   int jresult ;
23390   Dali::ResizePolicy::Type result;
23391
23392   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23399   unsigned long jresult ;
23400   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23401   Dali::VectorBase::SizeType result;
23402
23403   arg1 = (Dali::VectorBase *)jarg1;
23404   {
23405     try {
23406       result = ((Dali::VectorBase const *)arg1)->Count();
23407     } catch (std::out_of_range& e) {
23408       {
23409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23410       };
23411     } catch (std::exception& e) {
23412       {
23413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23414       };
23415     } catch (Dali::DaliException e) {
23416       {
23417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23418       };
23419     } catch (...) {
23420       {
23421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23422       };
23423     }
23424   }
23425
23426   jresult = (unsigned long)result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23432   unsigned long jresult ;
23433   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23434   Dali::VectorBase::SizeType result;
23435
23436   arg1 = (Dali::VectorBase *)jarg1;
23437   {
23438     try {
23439       result = ((Dali::VectorBase const *)arg1)->Size();
23440     } catch (std::out_of_range& e) {
23441       {
23442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23443       };
23444     } catch (std::exception& e) {
23445       {
23446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23447       };
23448     } catch (Dali::DaliException e) {
23449       {
23450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23451       };
23452     } catch (...) {
23453       {
23454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23455       };
23456     }
23457   }
23458
23459   jresult = (unsigned long)result;
23460   return jresult;
23461 }
23462
23463
23464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23465   unsigned int jresult ;
23466   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23467   bool result;
23468
23469   arg1 = (Dali::VectorBase *)jarg1;
23470   {
23471     try {
23472       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23473     } catch (std::out_of_range& e) {
23474       {
23475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23476       };
23477     } catch (std::exception& e) {
23478       {
23479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (Dali::DaliException e) {
23482       {
23483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23484       };
23485     } catch (...) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23488       };
23489     }
23490   }
23491
23492   jresult = result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23498   unsigned long jresult ;
23499   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23500   Dali::VectorBase::SizeType result;
23501
23502   arg1 = (Dali::VectorBase *)jarg1;
23503   {
23504     try {
23505       result = ((Dali::VectorBase const *)arg1)->Capacity();
23506     } catch (std::out_of_range& e) {
23507       {
23508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23509       };
23510     } catch (std::exception& e) {
23511       {
23512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23513       };
23514     } catch (Dali::DaliException e) {
23515       {
23516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23517       };
23518     } catch (...) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23521       };
23522     }
23523   }
23524
23525   jresult = (unsigned long)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23531   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23532
23533   arg1 = (Dali::VectorBase *)jarg1;
23534   {
23535     try {
23536       (arg1)->Release();
23537     } catch (std::out_of_range& e) {
23538       {
23539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23540       };
23541     } catch (std::exception& e) {
23542       {
23543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23544       };
23545     } catch (Dali::DaliException e) {
23546       {
23547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23548       };
23549     } catch (...) {
23550       {
23551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23552       };
23553     }
23554   }
23555
23556 }
23557
23558
23559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23560   void * jresult ;
23561   Dali::Image *result = 0 ;
23562
23563   {
23564     try {
23565       result = (Dali::Image *)new Dali::Image();
23566     } catch (std::out_of_range& e) {
23567       {
23568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23569       };
23570     } catch (std::exception& e) {
23571       {
23572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23573       };
23574     } catch (Dali::DaliException e) {
23575       {
23576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23577       };
23578     } catch (...) {
23579       {
23580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23581       };
23582     }
23583   }
23584
23585   jresult = (void *)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23591   Dali::Image *arg1 = (Dali::Image *) 0 ;
23592
23593   arg1 = (Dali::Image *)jarg1;
23594   {
23595     try {
23596       delete arg1;
23597     } catch (std::out_of_range& e) {
23598       {
23599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23600       };
23601     } catch (std::exception& e) {
23602       {
23603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23604       };
23605     } catch (Dali::DaliException e) {
23606       {
23607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23608       };
23609     } catch (...) {
23610       {
23611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23612       };
23613     }
23614   }
23615
23616 }
23617
23618
23619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23620   void * jresult ;
23621   Dali::Image *arg1 = 0 ;
23622   Dali::Image *result = 0 ;
23623
23624   arg1 = (Dali::Image *)jarg1;
23625   if (!arg1) {
23626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23627     return 0;
23628   }
23629   {
23630     try {
23631       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23632     } catch (std::out_of_range& e) {
23633       {
23634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (std::exception& e) {
23637       {
23638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (Dali::DaliException e) {
23641       {
23642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23643       };
23644     } catch (...) {
23645       {
23646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23647       };
23648     }
23649   }
23650
23651   jresult = (void *)result;
23652   return jresult;
23653 }
23654
23655
23656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23657   void * jresult ;
23658   Dali::Image *arg1 = (Dali::Image *) 0 ;
23659   Dali::Image *arg2 = 0 ;
23660   Dali::Image *result = 0 ;
23661
23662   arg1 = (Dali::Image *)jarg1;
23663   arg2 = (Dali::Image *)jarg2;
23664   if (!arg2) {
23665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23666     return 0;
23667   }
23668   {
23669     try {
23670       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23671     } catch (std::out_of_range& e) {
23672       {
23673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23674       };
23675     } catch (std::exception& e) {
23676       {
23677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (Dali::DaliException e) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23682       };
23683     } catch (...) {
23684       {
23685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23686       };
23687     }
23688   }
23689
23690   jresult = (void *)result;
23691   return jresult;
23692 }
23693
23694
23695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23696   void * jresult ;
23697   Dali::BaseHandle arg1 ;
23698   Dali::BaseHandle *argp1 ;
23699   Dali::Image result;
23700
23701   argp1 = (Dali::BaseHandle *)jarg1;
23702   if (!argp1) {
23703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23704     return 0;
23705   }
23706   arg1 = *argp1;
23707   {
23708     try {
23709       result = Dali::Image::DownCast(arg1);
23710     } catch (std::out_of_range& e) {
23711       {
23712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23713       };
23714     } catch (std::exception& e) {
23715       {
23716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23717       };
23718     } catch (Dali::DaliException e) {
23719       {
23720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23721       };
23722     } catch (...) {
23723       {
23724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23725       };
23726     }
23727   }
23728
23729   jresult = new Dali::Image((const Dali::Image &)result);
23730   return jresult;
23731 }
23732
23733
23734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23735   unsigned int jresult ;
23736   Dali::Image *arg1 = (Dali::Image *) 0 ;
23737   unsigned int result;
23738
23739   arg1 = (Dali::Image *)jarg1;
23740   {
23741     try {
23742       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23743     } catch (std::out_of_range& e) {
23744       {
23745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (std::exception& e) {
23748       {
23749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23750       };
23751     } catch (Dali::DaliException e) {
23752       {
23753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23754       };
23755     } catch (...) {
23756       {
23757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23758       };
23759     }
23760   }
23761
23762   jresult = result;
23763   return jresult;
23764 }
23765
23766
23767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23768   unsigned int jresult ;
23769   Dali::Image *arg1 = (Dali::Image *) 0 ;
23770   unsigned int result;
23771
23772   arg1 = (Dali::Image *)jarg1;
23773   {
23774     try {
23775       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23776     } catch (std::out_of_range& e) {
23777       {
23778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23779       };
23780     } catch (std::exception& e) {
23781       {
23782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23783       };
23784     } catch (Dali::DaliException e) {
23785       {
23786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23787       };
23788     } catch (...) {
23789       {
23790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23791       };
23792     }
23793   }
23794
23795   jresult = result;
23796   return jresult;
23797 }
23798
23799
23800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23801   void * jresult ;
23802   Dali::Image *arg1 = (Dali::Image *) 0 ;
23803   Dali::Image::ImageSignalType *result = 0 ;
23804
23805   arg1 = (Dali::Image *)jarg1;
23806   {
23807     try {
23808       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23809     } catch (std::out_of_range& e) {
23810       {
23811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23812       };
23813     } catch (std::exception& e) {
23814       {
23815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23816       };
23817     } catch (Dali::DaliException e) {
23818       {
23819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23820       };
23821     } catch (...) {
23822       {
23823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23824       };
23825     }
23826   }
23827
23828   jresult = (void *)result;
23829   return jresult;
23830 }
23831
23832
23833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23834   int jresult ;
23835   Dali::Pixel::Format result;
23836
23837   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23838   jresult = (int)result;
23839   return jresult;
23840 }
23841
23842
23843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23844   int jresult ;
23845   Dali::Pixel::Format result;
23846
23847   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23848   jresult = (int)result;
23849   return jresult;
23850 }
23851
23852
23853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23854   unsigned int jresult ;
23855   Dali::Pixel::Format arg1 ;
23856   bool result;
23857
23858   arg1 = (Dali::Pixel::Format)jarg1;
23859   {
23860     try {
23861       result = (bool)Dali::Pixel::HasAlpha(arg1);
23862     } catch (std::out_of_range& e) {
23863       {
23864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23865       };
23866     } catch (std::exception& e) {
23867       {
23868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23869       };
23870     } catch (Dali::DaliException e) {
23871       {
23872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23873       };
23874     } catch (...) {
23875       {
23876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23877       };
23878     }
23879   }
23880
23881   jresult = result;
23882   return jresult;
23883 }
23884
23885
23886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23887   unsigned int jresult ;
23888   Dali::Pixel::Format arg1 ;
23889   unsigned int result;
23890
23891   arg1 = (Dali::Pixel::Format)jarg1;
23892   {
23893     try {
23894       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23895     } catch (std::out_of_range& e) {
23896       {
23897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23898       };
23899     } catch (std::exception& e) {
23900       {
23901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (Dali::DaliException e) {
23904       {
23905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23906       };
23907     } catch (...) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23910       };
23911     }
23912   }
23913
23914   jresult = result;
23915   return jresult;
23916 }
23917
23918
23919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23920   Dali::Pixel::Format arg1 ;
23921   int *arg2 = 0 ;
23922   int *arg3 = 0 ;
23923
23924   arg1 = (Dali::Pixel::Format)jarg1;
23925   arg2 = (int *)jarg2;
23926   if (!arg2) {
23927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23928     return ;
23929   }
23930   arg3 = (int *)jarg3;
23931   if (!arg3) {
23932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23933     return ;
23934   }
23935   {
23936     try {
23937       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23938     } catch (std::out_of_range& e) {
23939       {
23940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23941       };
23942     } catch (std::exception& e) {
23943       {
23944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23945       };
23946     } catch (Dali::DaliException e) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23949       };
23950     } catch (...) {
23951       {
23952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23953       };
23954     }
23955   }
23956
23957 }
23958
23959
23960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23961   void * jresult ;
23962   unsigned char *arg1 = (unsigned char *) 0 ;
23963   unsigned int arg2 ;
23964   unsigned int arg3 ;
23965   unsigned int arg4 ;
23966   Dali::Pixel::Format arg5 ;
23967   Dali::PixelData::ReleaseFunction arg6 ;
23968   Dali::PixelData result;
23969
23970   arg1 = jarg1;
23971   arg2 = (unsigned int)jarg2;
23972   arg3 = (unsigned int)jarg3;
23973   arg4 = (unsigned int)jarg4;
23974   arg5 = (Dali::Pixel::Format)jarg5;
23975   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23976   {
23977     try {
23978       auto pixelBuffer = new unsigned char[jarg2];
23979       memcpy( pixelBuffer, arg1, arg2);
23980       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23981     } catch (std::out_of_range& e) {
23982       {
23983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (std::exception& e) {
23986       {
23987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23988       };
23989     } catch (Dali::DaliException e) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23992       };
23993     } catch (...) {
23994       {
23995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23996       };
23997     }
23998   }
23999
24000   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24001
24002
24003   return jresult;
24004 }
24005
24006
24007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24008   void * jresult ;
24009   Dali::PixelData *result = 0 ;
24010
24011   {
24012     try {
24013       result = (Dali::PixelData *)new Dali::PixelData();
24014     } catch (std::out_of_range& e) {
24015       {
24016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24017       };
24018     } catch (std::exception& e) {
24019       {
24020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24021       };
24022     } catch (Dali::DaliException e) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24025       };
24026     } catch (...) {
24027       {
24028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24029       };
24030     }
24031   }
24032
24033   jresult = (void *)result;
24034   return jresult;
24035 }
24036
24037
24038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24039   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24040
24041   arg1 = (Dali::PixelData *)jarg1;
24042   {
24043     try {
24044       delete arg1;
24045     } catch (std::out_of_range& e) {
24046       {
24047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24048       };
24049     } catch (std::exception& e) {
24050       {
24051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24052       };
24053     } catch (Dali::DaliException e) {
24054       {
24055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24056       };
24057     } catch (...) {
24058       {
24059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24060       };
24061     }
24062   }
24063
24064 }
24065
24066
24067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24068   void * jresult ;
24069   Dali::PixelData *arg1 = 0 ;
24070   Dali::PixelData *result = 0 ;
24071
24072   arg1 = (Dali::PixelData *)jarg1;
24073   if (!arg1) {
24074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24075     return 0;
24076   }
24077   {
24078     try {
24079       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24080     } catch (std::out_of_range& e) {
24081       {
24082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (std::exception& e) {
24085       {
24086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24087       };
24088     } catch (Dali::DaliException e) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24091       };
24092     } catch (...) {
24093       {
24094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24095       };
24096     }
24097   }
24098
24099   jresult = (void *)result;
24100   return jresult;
24101 }
24102
24103
24104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24105   void * jresult ;
24106   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24107   Dali::PixelData *arg2 = 0 ;
24108   Dali::PixelData *result = 0 ;
24109
24110   arg1 = (Dali::PixelData *)jarg1;
24111   arg2 = (Dali::PixelData *)jarg2;
24112   if (!arg2) {
24113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24114     return 0;
24115   }
24116   {
24117     try {
24118       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24119     } catch (std::out_of_range& e) {
24120       {
24121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24122       };
24123     } catch (std::exception& e) {
24124       {
24125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24126       };
24127     } catch (Dali::DaliException e) {
24128       {
24129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24130       };
24131     } catch (...) {
24132       {
24133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24134       };
24135     }
24136   }
24137
24138   jresult = (void *)result;
24139   return jresult;
24140 }
24141
24142
24143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24144   unsigned int jresult ;
24145   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24146   unsigned int result;
24147
24148   arg1 = (Dali::PixelData *)jarg1;
24149   {
24150     try {
24151       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24152     } catch (std::out_of_range& e) {
24153       {
24154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (std::exception& e) {
24157       {
24158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24159       };
24160     } catch (Dali::DaliException e) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24163       };
24164     } catch (...) {
24165       {
24166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24167       };
24168     }
24169   }
24170
24171   jresult = result;
24172   return jresult;
24173 }
24174
24175
24176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24177   unsigned int jresult ;
24178   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24179   unsigned int result;
24180
24181   arg1 = (Dali::PixelData *)jarg1;
24182   {
24183     try {
24184       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24185     } catch (std::out_of_range& e) {
24186       {
24187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (std::exception& e) {
24190       {
24191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24192       };
24193     } catch (Dali::DaliException e) {
24194       {
24195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24196       };
24197     } catch (...) {
24198       {
24199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24200       };
24201     }
24202   }
24203
24204   jresult = result;
24205   return jresult;
24206 }
24207
24208
24209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24210   int jresult ;
24211   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24212   Dali::Pixel::Format result;
24213
24214   arg1 = (Dali::PixelData *)jarg1;
24215   {
24216     try {
24217       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24218     } catch (std::out_of_range& e) {
24219       {
24220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (std::exception& e) {
24223       {
24224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24225       };
24226     } catch (Dali::DaliException e) {
24227       {
24228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24229       };
24230     } catch (...) {
24231       {
24232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24233       };
24234     }
24235   }
24236
24237   jresult = (int)result;
24238   return jresult;
24239 }
24240
24241
24242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24243   unsigned int jresult ;
24244   unsigned int result;
24245
24246   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24247   jresult = result;
24248   return jresult;
24249 }
24250
24251
24252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24253   unsigned int jresult ;
24254   unsigned int result;
24255
24256   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24257   jresult = result;
24258   return jresult;
24259 }
24260
24261
24262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24263   unsigned int jresult ;
24264   unsigned int result;
24265
24266   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24267   jresult = result;
24268   return jresult;
24269 }
24270
24271
24272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24273   unsigned int jresult ;
24274   unsigned int result;
24275
24276   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24277   jresult = result;
24278   return jresult;
24279 }
24280
24281
24282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24283   unsigned int jresult ;
24284   unsigned int result;
24285
24286   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24287   jresult = result;
24288   return jresult;
24289 }
24290
24291
24292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24293   unsigned int jresult ;
24294   unsigned int result;
24295
24296   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24297   jresult = result;
24298   return jresult;
24299 }
24300
24301
24302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24303   void * jresult ;
24304   Dali::TextureType::Type arg1 ;
24305   Dali::Pixel::Format arg2 ;
24306   unsigned int arg3 ;
24307   unsigned int arg4 ;
24308   Dali::Texture result;
24309
24310   arg1 = (Dali::TextureType::Type)jarg1;
24311   arg2 = (Dali::Pixel::Format)jarg2;
24312   arg3 = (unsigned int)jarg3;
24313   arg4 = (unsigned int)jarg4;
24314   {
24315     try {
24316       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24317     } catch (std::out_of_range& e) {
24318       {
24319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24320       };
24321     } catch (std::exception& e) {
24322       {
24323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24324       };
24325     } catch (Dali::DaliException e) {
24326       {
24327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24328       };
24329     } catch (...) {
24330       {
24331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24332       };
24333     }
24334   }
24335
24336   jresult = new Dali::Texture((const Dali::Texture &)result);
24337   return jresult;
24338 }
24339
24340
24341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24342   void * jresult ;
24343   NativeImageInterface *arg1 = 0 ;
24344   Dali::Texture result;
24345
24346   arg1 = (NativeImageInterface *)jarg1;
24347   if (!arg1) {
24348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24349     return 0;
24350   }
24351   {
24352     try {
24353       result = Dali::Texture::New(*arg1);
24354     } catch (std::out_of_range& e) {
24355       {
24356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24357       };
24358     } catch (std::exception& e) {
24359       {
24360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24361       };
24362     } catch (Dali::DaliException e) {
24363       {
24364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24365       };
24366     } catch (...) {
24367       {
24368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24369       };
24370     }
24371   }
24372
24373   jresult = new Dali::Texture((const Dali::Texture &)result);
24374   return jresult;
24375 }
24376
24377
24378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24379   void * jresult ;
24380   Dali::Texture *result = 0 ;
24381
24382   {
24383     try {
24384       result = (Dali::Texture *)new Dali::Texture();
24385     } catch (std::out_of_range& e) {
24386       {
24387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (std::exception& e) {
24390       {
24391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24392       };
24393     } catch (Dali::DaliException e) {
24394       {
24395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24396       };
24397     } catch (...) {
24398       {
24399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24400       };
24401     }
24402   }
24403
24404   jresult = (void *)result;
24405   return jresult;
24406 }
24407
24408
24409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24410   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24411
24412   arg1 = (Dali::Texture *)jarg1;
24413   {
24414     try {
24415       delete arg1;
24416     } catch (std::out_of_range& e) {
24417       {
24418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24419       };
24420     } catch (std::exception& e) {
24421       {
24422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24423       };
24424     } catch (Dali::DaliException e) {
24425       {
24426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24427       };
24428     } catch (...) {
24429       {
24430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24431       };
24432     }
24433   }
24434
24435 }
24436
24437
24438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24439   void * jresult ;
24440   Dali::Texture *arg1 = 0 ;
24441   Dali::Texture *result = 0 ;
24442
24443   arg1 = (Dali::Texture *)jarg1;
24444   if (!arg1) {
24445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24446     return 0;
24447   }
24448   {
24449     try {
24450       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24451     } catch (std::out_of_range& e) {
24452       {
24453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24454       };
24455     } catch (std::exception& e) {
24456       {
24457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24458       };
24459     } catch (Dali::DaliException e) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24462       };
24463     } catch (...) {
24464       {
24465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24466       };
24467     }
24468   }
24469
24470   jresult = (void *)result;
24471   return jresult;
24472 }
24473
24474
24475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24476   void * jresult ;
24477   Dali::BaseHandle arg1 ;
24478   Dali::BaseHandle *argp1 ;
24479   Dali::Texture result;
24480
24481   argp1 = (Dali::BaseHandle *)jarg1;
24482   if (!argp1) {
24483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24484     return 0;
24485   }
24486   arg1 = *argp1;
24487   {
24488     try {
24489       result = Dali::Texture::DownCast(arg1);
24490     } catch (std::out_of_range& e) {
24491       {
24492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (std::exception& e) {
24495       {
24496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24497       };
24498     } catch (Dali::DaliException e) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24501       };
24502     } catch (...) {
24503       {
24504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24505       };
24506     }
24507   }
24508
24509   jresult = new Dali::Texture((const Dali::Texture &)result);
24510   return jresult;
24511 }
24512
24513
24514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24515   void * jresult ;
24516   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24517   Dali::Texture *arg2 = 0 ;
24518   Dali::Texture *result = 0 ;
24519
24520   arg1 = (Dali::Texture *)jarg1;
24521   arg2 = (Dali::Texture *)jarg2;
24522   if (!arg2) {
24523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24524     return 0;
24525   }
24526   {
24527     try {
24528       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24529     } catch (std::out_of_range& e) {
24530       {
24531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (std::exception& e) {
24534       {
24535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (Dali::DaliException e) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547
24548   jresult = (void *)result;
24549   return jresult;
24550 }
24551
24552
24553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24554   unsigned int jresult ;
24555   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24556   Dali::PixelData arg2 ;
24557   Dali::PixelData *argp2 ;
24558   bool result;
24559
24560   arg1 = (Dali::Texture *)jarg1;
24561   argp2 = (Dali::PixelData *)jarg2;
24562   if (!argp2) {
24563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24564     return 0;
24565   }
24566   arg2 = *argp2;
24567   {
24568     try {
24569       result = (bool)(arg1)->Upload(arg2);
24570     } catch (std::out_of_range& e) {
24571       {
24572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24573       };
24574     } catch (std::exception& e) {
24575       {
24576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24577       };
24578     } catch (Dali::DaliException e) {
24579       {
24580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24581       };
24582     } catch (...) {
24583       {
24584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24585       };
24586     }
24587   }
24588
24589   jresult = result;
24590   return jresult;
24591 }
24592
24593
24594 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) {
24595   unsigned int jresult ;
24596   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24597   Dali::PixelData arg2 ;
24598   unsigned int arg3 ;
24599   unsigned int arg4 ;
24600   unsigned int arg5 ;
24601   unsigned int arg6 ;
24602   unsigned int arg7 ;
24603   unsigned int arg8 ;
24604   Dali::PixelData *argp2 ;
24605   bool result;
24606
24607   arg1 = (Dali::Texture *)jarg1;
24608   argp2 = (Dali::PixelData *)jarg2;
24609   if (!argp2) {
24610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24611     return 0;
24612   }
24613   arg2 = *argp2;
24614   arg3 = (unsigned int)jarg3;
24615   arg4 = (unsigned int)jarg4;
24616   arg5 = (unsigned int)jarg5;
24617   arg6 = (unsigned int)jarg6;
24618   arg7 = (unsigned int)jarg7;
24619   arg8 = (unsigned int)jarg8;
24620   {
24621     try {
24622       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24623     } catch (std::out_of_range& e) {
24624       {
24625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24626       };
24627     } catch (std::exception& e) {
24628       {
24629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24630       };
24631     } catch (Dali::DaliException e) {
24632       {
24633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24634       };
24635     } catch (...) {
24636       {
24637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24638       };
24639     }
24640   }
24641
24642   jresult = result;
24643   return jresult;
24644 }
24645
24646
24647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24648   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24649
24650   arg1 = (Dali::Texture *)jarg1;
24651   {
24652     try {
24653       (arg1)->GenerateMipmaps();
24654     } catch (std::out_of_range& e) {
24655       {
24656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24657       };
24658     } catch (std::exception& e) {
24659       {
24660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24661       };
24662     } catch (Dali::DaliException e) {
24663       {
24664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24665       };
24666     } catch (...) {
24667       {
24668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24669       };
24670     }
24671   }
24672
24673 }
24674
24675
24676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24677   unsigned int jresult ;
24678   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24679   unsigned int result;
24680
24681   arg1 = (Dali::Texture *)jarg1;
24682   {
24683     try {
24684       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24685     } catch (std::out_of_range& e) {
24686       {
24687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24688       };
24689     } catch (std::exception& e) {
24690       {
24691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24692       };
24693     } catch (Dali::DaliException e) {
24694       {
24695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24696       };
24697     } catch (...) {
24698       {
24699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24700       };
24701     }
24702   }
24703
24704   jresult = result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24710   unsigned int jresult ;
24711   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24712   unsigned int result;
24713
24714   arg1 = (Dali::Texture *)jarg1;
24715   {
24716     try {
24717       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24718     } catch (std::out_of_range& e) {
24719       {
24720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24721       };
24722     } catch (std::exception& e) {
24723       {
24724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24725       };
24726     } catch (Dali::DaliException e) {
24727       {
24728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24729       };
24730     } catch (...) {
24731       {
24732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24733       };
24734     }
24735   }
24736
24737   jresult = result;
24738   return jresult;
24739 }
24740
24741
24742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24743   void * jresult ;
24744   Dali::Sampler result;
24745
24746   {
24747     try {
24748       result = Dali::Sampler::New();
24749     } catch (std::out_of_range& e) {
24750       {
24751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24752       };
24753     } catch (std::exception& e) {
24754       {
24755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24756       };
24757     } catch (Dali::DaliException e) {
24758       {
24759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24760       };
24761     } catch (...) {
24762       {
24763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24764       };
24765     }
24766   }
24767
24768   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24769   return jresult;
24770 }
24771
24772
24773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24774   void * jresult ;
24775   Dali::Sampler *result = 0 ;
24776
24777   {
24778     try {
24779       result = (Dali::Sampler *)new Dali::Sampler();
24780     } catch (std::out_of_range& e) {
24781       {
24782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (std::exception& e) {
24785       {
24786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24787       };
24788     } catch (Dali::DaliException e) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24791       };
24792     } catch (...) {
24793       {
24794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24795       };
24796     }
24797   }
24798
24799   jresult = (void *)result;
24800   return jresult;
24801 }
24802
24803
24804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24805   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24806
24807   arg1 = (Dali::Sampler *)jarg1;
24808   {
24809     try {
24810       delete arg1;
24811     } catch (std::out_of_range& e) {
24812       {
24813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (std::exception& e) {
24816       {
24817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24818       };
24819     } catch (Dali::DaliException e) {
24820       {
24821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24822       };
24823     } catch (...) {
24824       {
24825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24826       };
24827     }
24828   }
24829
24830 }
24831
24832
24833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24834   void * jresult ;
24835   Dali::Sampler *arg1 = 0 ;
24836   Dali::Sampler *result = 0 ;
24837
24838   arg1 = (Dali::Sampler *)jarg1;
24839   if (!arg1) {
24840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24841     return 0;
24842   }
24843   {
24844     try {
24845       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24846     } catch (std::out_of_range& e) {
24847       {
24848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24849       };
24850     } catch (std::exception& e) {
24851       {
24852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24853       };
24854     } catch (Dali::DaliException e) {
24855       {
24856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24857       };
24858     } catch (...) {
24859       {
24860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24861       };
24862     }
24863   }
24864
24865   jresult = (void *)result;
24866   return jresult;
24867 }
24868
24869
24870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24871   void * jresult ;
24872   Dali::BaseHandle arg1 ;
24873   Dali::BaseHandle *argp1 ;
24874   Dali::Sampler result;
24875
24876   argp1 = (Dali::BaseHandle *)jarg1;
24877   if (!argp1) {
24878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24879     return 0;
24880   }
24881   arg1 = *argp1;
24882   {
24883     try {
24884       result = Dali::Sampler::DownCast(arg1);
24885     } catch (std::out_of_range& e) {
24886       {
24887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24888       };
24889     } catch (std::exception& e) {
24890       {
24891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24892       };
24893     } catch (Dali::DaliException e) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24896       };
24897     } catch (...) {
24898       {
24899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24900       };
24901     }
24902   }
24903
24904   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24905   return jresult;
24906 }
24907
24908
24909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24910   void * jresult ;
24911   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24912   Dali::Sampler *arg2 = 0 ;
24913   Dali::Sampler *result = 0 ;
24914
24915   arg1 = (Dali::Sampler *)jarg1;
24916   arg2 = (Dali::Sampler *)jarg2;
24917   if (!arg2) {
24918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24919     return 0;
24920   }
24921   {
24922     try {
24923       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24924     } catch (std::out_of_range& e) {
24925       {
24926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24927       };
24928     } catch (std::exception& e) {
24929       {
24930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24931       };
24932     } catch (Dali::DaliException e) {
24933       {
24934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24935       };
24936     } catch (...) {
24937       {
24938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24939       };
24940     }
24941   }
24942
24943   jresult = (void *)result;
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24949   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24950   Dali::FilterMode::Type arg2 ;
24951   Dali::FilterMode::Type arg3 ;
24952
24953   arg1 = (Dali::Sampler *)jarg1;
24954   arg2 = (Dali::FilterMode::Type)jarg2;
24955   arg3 = (Dali::FilterMode::Type)jarg3;
24956   {
24957     try {
24958       (arg1)->SetFilterMode(arg2,arg3);
24959     } catch (std::out_of_range& e) {
24960       {
24961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24962       };
24963     } catch (std::exception& e) {
24964       {
24965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24966       };
24967     } catch (Dali::DaliException e) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24970       };
24971     } catch (...) {
24972       {
24973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24974       };
24975     }
24976   }
24977
24978 }
24979
24980
24981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24982   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24983   Dali::WrapMode::Type arg2 ;
24984   Dali::WrapMode::Type arg3 ;
24985
24986   arg1 = (Dali::Sampler *)jarg1;
24987   arg2 = (Dali::WrapMode::Type)jarg2;
24988   arg3 = (Dali::WrapMode::Type)jarg3;
24989   {
24990     try {
24991       (arg1)->SetWrapMode(arg2,arg3);
24992     } catch (std::out_of_range& e) {
24993       {
24994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24995       };
24996     } catch (std::exception& e) {
24997       {
24998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24999       };
25000     } catch (Dali::DaliException e) {
25001       {
25002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25003       };
25004     } catch (...) {
25005       {
25006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25007       };
25008     }
25009   }
25010
25011 }
25012
25013
25014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25015   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25016   Dali::WrapMode::Type arg2 ;
25017   Dali::WrapMode::Type arg3 ;
25018   Dali::WrapMode::Type arg4 ;
25019
25020   arg1 = (Dali::Sampler *)jarg1;
25021   arg2 = (Dali::WrapMode::Type)jarg2;
25022   arg3 = (Dali::WrapMode::Type)jarg3;
25023   arg4 = (Dali::WrapMode::Type)jarg4;
25024   {
25025     try {
25026       (arg1)->SetWrapMode(arg2,arg3,arg4);
25027     } catch (std::out_of_range& e) {
25028       {
25029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25030       };
25031     } catch (std::exception& e) {
25032       {
25033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25034       };
25035     } catch (Dali::DaliException e) {
25036       {
25037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25038       };
25039     } catch (...) {
25040       {
25041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25042       };
25043     }
25044   }
25045
25046 }
25047
25048
25049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25050   void * jresult ;
25051   Dali::TextureSet result;
25052
25053   {
25054     try {
25055       result = Dali::TextureSet::New();
25056     } catch (std::out_of_range& e) {
25057       {
25058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25059       };
25060     } catch (std::exception& e) {
25061       {
25062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25063       };
25064     } catch (Dali::DaliException e) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25067       };
25068     } catch (...) {
25069       {
25070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25071       };
25072     }
25073   }
25074
25075   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25076   return jresult;
25077 }
25078
25079
25080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25081   void * jresult ;
25082   Dali::TextureSet *result = 0 ;
25083
25084   {
25085     try {
25086       result = (Dali::TextureSet *)new Dali::TextureSet();
25087     } catch (std::out_of_range& e) {
25088       {
25089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25090       };
25091     } catch (std::exception& e) {
25092       {
25093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25094       };
25095     } catch (Dali::DaliException e) {
25096       {
25097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25098       };
25099     } catch (...) {
25100       {
25101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25102       };
25103     }
25104   }
25105
25106   jresult = (void *)result;
25107   return jresult;
25108 }
25109
25110
25111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25112   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25113
25114   arg1 = (Dali::TextureSet *)jarg1;
25115   {
25116     try {
25117       delete arg1;
25118     } catch (std::out_of_range& e) {
25119       {
25120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (std::exception& e) {
25123       {
25124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25125       };
25126     } catch (Dali::DaliException e) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25129       };
25130     } catch (...) {
25131       {
25132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25133       };
25134     }
25135   }
25136
25137 }
25138
25139
25140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25141   void * jresult ;
25142   Dali::TextureSet *arg1 = 0 ;
25143   Dali::TextureSet *result = 0 ;
25144
25145   arg1 = (Dali::TextureSet *)jarg1;
25146   if (!arg1) {
25147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25148     return 0;
25149   }
25150   {
25151     try {
25152       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25153     } catch (std::out_of_range& e) {
25154       {
25155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25156       };
25157     } catch (std::exception& e) {
25158       {
25159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25160       };
25161     } catch (Dali::DaliException e) {
25162       {
25163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25164       };
25165     } catch (...) {
25166       {
25167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25168       };
25169     }
25170   }
25171
25172   jresult = (void *)result;
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25178   void * jresult ;
25179   Dali::BaseHandle arg1 ;
25180   Dali::BaseHandle *argp1 ;
25181   Dali::TextureSet result;
25182
25183   argp1 = (Dali::BaseHandle *)jarg1;
25184   if (!argp1) {
25185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25186     return 0;
25187   }
25188   arg1 = *argp1;
25189   {
25190     try {
25191       result = Dali::TextureSet::DownCast(arg1);
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25199       };
25200     } catch (Dali::DaliException e) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25203       };
25204     } catch (...) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25207       };
25208     }
25209   }
25210
25211   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25212   return jresult;
25213 }
25214
25215
25216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25217   void * jresult ;
25218   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25219   Dali::TextureSet *arg2 = 0 ;
25220   Dali::TextureSet *result = 0 ;
25221
25222   arg1 = (Dali::TextureSet *)jarg1;
25223   arg2 = (Dali::TextureSet *)jarg2;
25224   if (!arg2) {
25225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25226     return 0;
25227   }
25228   {
25229     try {
25230       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25231     } catch (std::out_of_range& e) {
25232       {
25233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25234       };
25235     } catch (std::exception& e) {
25236       {
25237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25238       };
25239     } catch (Dali::DaliException e) {
25240       {
25241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25242       };
25243     } catch (...) {
25244       {
25245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25246       };
25247     }
25248   }
25249
25250   jresult = (void *)result;
25251   return jresult;
25252 }
25253
25254
25255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25256   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25257   size_t arg2 ;
25258   Dali::Texture arg3 ;
25259   Dali::Texture *argp3 ;
25260
25261   arg1 = (Dali::TextureSet *)jarg1;
25262   arg2 = (size_t)jarg2;
25263   argp3 = (Dali::Texture *)jarg3;
25264   if (!argp3) {
25265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25266     return ;
25267   }
25268   arg3 = *argp3;
25269   {
25270     try {
25271       (arg1)->SetTexture(arg2,arg3);
25272     } catch (std::out_of_range& e) {
25273       {
25274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25275       };
25276     } catch (std::exception& e) {
25277       {
25278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25279       };
25280     } catch (Dali::DaliException e) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25283       };
25284     } catch (...) {
25285       {
25286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25287       };
25288     }
25289   }
25290
25291 }
25292
25293
25294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25295   void * jresult ;
25296   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25297   size_t arg2 ;
25298   Dali::Texture result;
25299
25300   arg1 = (Dali::TextureSet *)jarg1;
25301   arg2 = (size_t)jarg2;
25302   {
25303     try {
25304       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25305     } catch (std::out_of_range& e) {
25306       {
25307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (std::exception& e) {
25310       {
25311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25312       };
25313     } catch (Dali::DaliException e) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25316       };
25317     } catch (...) {
25318       {
25319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25320       };
25321     }
25322   }
25323
25324   jresult = new Dali::Texture((const Dali::Texture &)result);
25325   return jresult;
25326 }
25327
25328
25329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25330   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25331   size_t arg2 ;
25332   Dali::Sampler arg3 ;
25333   Dali::Sampler *argp3 ;
25334
25335   arg1 = (Dali::TextureSet *)jarg1;
25336   arg2 = (size_t)jarg2;
25337   argp3 = (Dali::Sampler *)jarg3;
25338   if (!argp3) {
25339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25340     return ;
25341   }
25342   arg3 = *argp3;
25343   {
25344     try {
25345       (arg1)->SetSampler(arg2,arg3);
25346     } catch (std::out_of_range& e) {
25347       {
25348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25349       };
25350     } catch (std::exception& e) {
25351       {
25352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25353       };
25354     } catch (Dali::DaliException e) {
25355       {
25356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25357       };
25358     } catch (...) {
25359       {
25360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25361       };
25362     }
25363   }
25364
25365 }
25366
25367
25368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25369   void * jresult ;
25370   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25371   size_t arg2 ;
25372   Dali::Sampler result;
25373
25374   arg1 = (Dali::TextureSet *)jarg1;
25375   arg2 = (size_t)jarg2;
25376   {
25377     try {
25378       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25379     } catch (std::out_of_range& e) {
25380       {
25381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (std::exception& e) {
25384       {
25385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25386       };
25387     } catch (Dali::DaliException e) {
25388       {
25389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25390       };
25391     } catch (...) {
25392       {
25393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25394       };
25395     }
25396   }
25397
25398   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25399   return jresult;
25400 }
25401
25402
25403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25404   unsigned long jresult ;
25405   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25406   size_t result;
25407
25408   arg1 = (Dali::TextureSet *)jarg1;
25409   {
25410     try {
25411       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25412     } catch (std::out_of_range& e) {
25413       {
25414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25415       };
25416     } catch (std::exception& e) {
25417       {
25418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25419       };
25420     } catch (Dali::DaliException e) {
25421       {
25422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25423       };
25424     } catch (...) {
25425       {
25426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25427       };
25428     }
25429   }
25430
25431   jresult = (unsigned long)result;
25432   return jresult;
25433 }
25434
25435
25436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25437   void * jresult ;
25438   Dali::Property::Map *arg1 = 0 ;
25439   Dali::PropertyBuffer result;
25440
25441   arg1 = (Dali::Property::Map *)jarg1;
25442   if (!arg1) {
25443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25444     return 0;
25445   }
25446   {
25447     try {
25448       result = Dali::PropertyBuffer::New(*arg1);
25449     } catch (std::out_of_range& e) {
25450       {
25451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25452       };
25453     } catch (std::exception& e) {
25454       {
25455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (Dali::DaliException e) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25460       };
25461     } catch (...) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25464       };
25465     }
25466   }
25467
25468   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25469   return jresult;
25470 }
25471
25472
25473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25474   void * jresult ;
25475   Dali::PropertyBuffer *result = 0 ;
25476
25477   {
25478     try {
25479       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25480     } catch (std::out_of_range& e) {
25481       {
25482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25483       };
25484     } catch (std::exception& e) {
25485       {
25486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (Dali::DaliException e) {
25489       {
25490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25491       };
25492     } catch (...) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25495       };
25496     }
25497   }
25498
25499   jresult = (void *)result;
25500   return jresult;
25501 }
25502
25503
25504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25505   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25506
25507   arg1 = (Dali::PropertyBuffer *)jarg1;
25508   {
25509     try {
25510       delete arg1;
25511     } catch (std::out_of_range& e) {
25512       {
25513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25514       };
25515     } catch (std::exception& e) {
25516       {
25517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25518       };
25519     } catch (Dali::DaliException e) {
25520       {
25521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25522       };
25523     } catch (...) {
25524       {
25525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25526       };
25527     }
25528   }
25529
25530 }
25531
25532
25533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25534   void * jresult ;
25535   Dali::PropertyBuffer *arg1 = 0 ;
25536   Dali::PropertyBuffer *result = 0 ;
25537
25538   arg1 = (Dali::PropertyBuffer *)jarg1;
25539   if (!arg1) {
25540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25541     return 0;
25542   }
25543   {
25544     try {
25545       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25546     } catch (std::out_of_range& e) {
25547       {
25548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25549       };
25550     } catch (std::exception& e) {
25551       {
25552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25553       };
25554     } catch (Dali::DaliException e) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25557       };
25558     } catch (...) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25561       };
25562     }
25563   }
25564
25565   jresult = (void *)result;
25566   return jresult;
25567 }
25568
25569
25570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25571   void * jresult ;
25572   Dali::BaseHandle arg1 ;
25573   Dali::BaseHandle *argp1 ;
25574   Dali::PropertyBuffer result;
25575
25576   argp1 = (Dali::BaseHandle *)jarg1;
25577   if (!argp1) {
25578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25579     return 0;
25580   }
25581   arg1 = *argp1;
25582   {
25583     try {
25584       result = Dali::PropertyBuffer::DownCast(arg1);
25585     } catch (std::out_of_range& e) {
25586       {
25587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25588       };
25589     } catch (std::exception& e) {
25590       {
25591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25592       };
25593     } catch (Dali::DaliException e) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25596       };
25597     } catch (...) {
25598       {
25599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25600       };
25601     }
25602   }
25603
25604   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25605   return jresult;
25606 }
25607
25608
25609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25610   void * jresult ;
25611   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25612   Dali::PropertyBuffer *arg2 = 0 ;
25613   Dali::PropertyBuffer *result = 0 ;
25614
25615   arg1 = (Dali::PropertyBuffer *)jarg1;
25616   arg2 = (Dali::PropertyBuffer *)jarg2;
25617   if (!arg2) {
25618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25619     return 0;
25620   }
25621   {
25622     try {
25623       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25624     } catch (std::out_of_range& e) {
25625       {
25626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (std::exception& e) {
25629       {
25630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25631       };
25632     } catch (Dali::DaliException e) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25635       };
25636     } catch (...) {
25637       {
25638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25639       };
25640     }
25641   }
25642
25643   jresult = (void *)result;
25644   return jresult;
25645 }
25646
25647
25648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25649   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25650   void *arg2 = (void *) 0 ;
25651   std::size_t arg3 ;
25652
25653   arg1 = (Dali::PropertyBuffer *)jarg1;
25654   arg2 = jarg2;
25655   arg3 = (std::size_t)jarg3;
25656   {
25657     try {
25658       (arg1)->SetData((void const *)arg2,arg3);
25659     } catch (std::out_of_range& e) {
25660       {
25661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25662       };
25663     } catch (std::exception& e) {
25664       {
25665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25666       };
25667     } catch (Dali::DaliException e) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25670       };
25671     } catch (...) {
25672       {
25673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25674       };
25675     }
25676   }
25677
25678 }
25679
25680
25681 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25682   unsigned long jresult ;
25683   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25684   std::size_t result;
25685
25686   arg1 = (Dali::PropertyBuffer *)jarg1;
25687   {
25688     try {
25689       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25690     } catch (std::out_of_range& e) {
25691       {
25692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25693       };
25694     } catch (std::exception& e) {
25695       {
25696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25697       };
25698     } catch (Dali::DaliException e) {
25699       {
25700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25701       };
25702     } catch (...) {
25703       {
25704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25705       };
25706     }
25707   }
25708
25709   jresult = (unsigned long)result;
25710   return jresult;
25711 }
25712
25713
25714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25715   void * jresult ;
25716   Dali::Geometry result;
25717
25718   {
25719     try {
25720       result = Dali::Geometry::New();
25721     } catch (std::out_of_range& e) {
25722       {
25723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25724       };
25725     } catch (std::exception& e) {
25726       {
25727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25728       };
25729     } catch (Dali::DaliException e) {
25730       {
25731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25732       };
25733     } catch (...) {
25734       {
25735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25736       };
25737     }
25738   }
25739
25740   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25741   return jresult;
25742 }
25743
25744
25745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25746   void * jresult ;
25747   Dali::Geometry *result = 0 ;
25748
25749   {
25750     try {
25751       result = (Dali::Geometry *)new Dali::Geometry();
25752     } catch (std::out_of_range& e) {
25753       {
25754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (std::exception& e) {
25757       {
25758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25759       };
25760     } catch (Dali::DaliException e) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25763       };
25764     } catch (...) {
25765       {
25766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25767       };
25768     }
25769   }
25770
25771   jresult = (void *)result;
25772   return jresult;
25773 }
25774
25775
25776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25777   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25778
25779   arg1 = (Dali::Geometry *)jarg1;
25780   {
25781     try {
25782       delete arg1;
25783     } catch (std::out_of_range& e) {
25784       {
25785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25786       };
25787     } catch (std::exception& e) {
25788       {
25789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25790       };
25791     } catch (Dali::DaliException e) {
25792       {
25793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25794       };
25795     } catch (...) {
25796       {
25797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25798       };
25799     }
25800   }
25801
25802 }
25803
25804
25805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25806   void * jresult ;
25807   Dali::Geometry *arg1 = 0 ;
25808   Dali::Geometry *result = 0 ;
25809
25810   arg1 = (Dali::Geometry *)jarg1;
25811   if (!arg1) {
25812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25813     return 0;
25814   }
25815   {
25816     try {
25817       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25818     } catch (std::out_of_range& e) {
25819       {
25820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (std::exception& e) {
25823       {
25824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25825       };
25826     } catch (Dali::DaliException e) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25829       };
25830     } catch (...) {
25831       {
25832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25833       };
25834     }
25835   }
25836
25837   jresult = (void *)result;
25838   return jresult;
25839 }
25840
25841
25842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25843   void * jresult ;
25844   Dali::BaseHandle arg1 ;
25845   Dali::BaseHandle *argp1 ;
25846   Dali::Geometry result;
25847
25848   argp1 = (Dali::BaseHandle *)jarg1;
25849   if (!argp1) {
25850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25851     return 0;
25852   }
25853   arg1 = *argp1;
25854   {
25855     try {
25856       result = Dali::Geometry::DownCast(arg1);
25857     } catch (std::out_of_range& e) {
25858       {
25859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (std::exception& e) {
25862       {
25863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25864       };
25865     } catch (Dali::DaliException e) {
25866       {
25867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25868       };
25869     } catch (...) {
25870       {
25871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25872       };
25873     }
25874   }
25875
25876   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25877   return jresult;
25878 }
25879
25880
25881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25882   void * jresult ;
25883   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25884   Dali::Geometry *arg2 = 0 ;
25885   Dali::Geometry *result = 0 ;
25886
25887   arg1 = (Dali::Geometry *)jarg1;
25888   arg2 = (Dali::Geometry *)jarg2;
25889   if (!arg2) {
25890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25891     return 0;
25892   }
25893   {
25894     try {
25895       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25896     } catch (std::out_of_range& e) {
25897       {
25898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (std::exception& e) {
25901       {
25902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25903       };
25904     } catch (Dali::DaliException e) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25907       };
25908     } catch (...) {
25909       {
25910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25911       };
25912     }
25913   }
25914
25915   jresult = (void *)result;
25916   return jresult;
25917 }
25918
25919
25920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25921   unsigned long jresult ;
25922   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25923   Dali::PropertyBuffer *arg2 = 0 ;
25924   std::size_t result;
25925
25926   arg1 = (Dali::Geometry *)jarg1;
25927   arg2 = (Dali::PropertyBuffer *)jarg2;
25928   if (!arg2) {
25929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25930     return 0;
25931   }
25932   {
25933     try {
25934       result = (arg1)->AddVertexBuffer(*arg2);
25935     } catch (std::out_of_range& e) {
25936       {
25937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25938       };
25939     } catch (std::exception& e) {
25940       {
25941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25942       };
25943     } catch (Dali::DaliException e) {
25944       {
25945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25946       };
25947     } catch (...) {
25948       {
25949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25950       };
25951     }
25952   }
25953
25954   jresult = (unsigned long)result;
25955   return jresult;
25956 }
25957
25958
25959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25960   unsigned long jresult ;
25961   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25962   std::size_t result;
25963
25964   arg1 = (Dali::Geometry *)jarg1;
25965   {
25966     try {
25967       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25968     } catch (std::out_of_range& e) {
25969       {
25970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25971       };
25972     } catch (std::exception& e) {
25973       {
25974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25975       };
25976     } catch (Dali::DaliException e) {
25977       {
25978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25979       };
25980     } catch (...) {
25981       {
25982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25983       };
25984     }
25985   }
25986
25987   jresult = (unsigned long)result;
25988   return jresult;
25989 }
25990
25991
25992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25993   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25994   std::size_t arg2 ;
25995
25996   arg1 = (Dali::Geometry *)jarg1;
25997   arg2 = (std::size_t)jarg2;
25998   {
25999     try {
26000       (arg1)->RemoveVertexBuffer(arg2);
26001     } catch (std::out_of_range& e) {
26002       {
26003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26004       };
26005     } catch (std::exception& e) {
26006       {
26007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26008       };
26009     } catch (Dali::DaliException e) {
26010       {
26011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26012       };
26013     } catch (...) {
26014       {
26015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26016       };
26017     }
26018   }
26019
26020 }
26021
26022
26023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26024   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26025   unsigned short *arg2 = (unsigned short *) 0 ;
26026   size_t arg3 ;
26027
26028   arg1 = (Dali::Geometry *)jarg1;
26029   arg2 = jarg2;
26030   arg3 = (size_t)jarg3;
26031   {
26032     try {
26033       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26034     } catch (std::out_of_range& e) {
26035       {
26036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26037       };
26038     } catch (std::exception& e) {
26039       {
26040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26041       };
26042     } catch (Dali::DaliException e) {
26043       {
26044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26045       };
26046     } catch (...) {
26047       {
26048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26049       };
26050     }
26051   }
26052
26053
26054
26055 }
26056
26057
26058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26059   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26060   Dali::Geometry::Type arg2 ;
26061
26062   arg1 = (Dali::Geometry *)jarg1;
26063   arg2 = (Dali::Geometry::Type)jarg2;
26064   {
26065     try {
26066       (arg1)->SetType(arg2);
26067     } catch (std::out_of_range& e) {
26068       {
26069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26070       };
26071     } catch (std::exception& e) {
26072       {
26073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26074       };
26075     } catch (Dali::DaliException e) {
26076       {
26077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26078       };
26079     } catch (...) {
26080       {
26081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26082       };
26083     }
26084   }
26085
26086 }
26087
26088
26089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26090   int jresult ;
26091   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26092   Dali::Geometry::Type result;
26093
26094   arg1 = (Dali::Geometry *)jarg1;
26095   {
26096     try {
26097       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26098     } catch (std::out_of_range& e) {
26099       {
26100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26101       };
26102     } catch (std::exception& e) {
26103       {
26104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26105       };
26106     } catch (Dali::DaliException e) {
26107       {
26108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26109       };
26110     } catch (...) {
26111       {
26112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26113       };
26114     }
26115   }
26116
26117   jresult = (int)result;
26118   return jresult;
26119 }
26120
26121
26122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26123   void * jresult ;
26124   Dali::Shader::Hint *result = 0 ;
26125
26126   {
26127     try {
26128       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26129     } catch (std::out_of_range& e) {
26130       {
26131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26132       };
26133     } catch (std::exception& e) {
26134       {
26135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26136       };
26137     } catch (Dali::DaliException e) {
26138       {
26139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26140       };
26141     } catch (...) {
26142       {
26143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26144       };
26145     }
26146   }
26147
26148   jresult = (void *)result;
26149   return jresult;
26150 }
26151
26152
26153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26154   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26155
26156   arg1 = (Dali::Shader::Hint *)jarg1;
26157   {
26158     try {
26159       delete arg1;
26160     } catch (std::out_of_range& e) {
26161       {
26162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26163       };
26164     } catch (std::exception& e) {
26165       {
26166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26167       };
26168     } catch (Dali::DaliException e) {
26169       {
26170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26171       };
26172     } catch (...) {
26173       {
26174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26175       };
26176     }
26177   }
26178
26179 }
26180
26181
26182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26183   int jresult ;
26184   int result;
26185
26186   result = (int)Dali::Shader::Property::PROGRAM;
26187   jresult = (int)result;
26188   return jresult;
26189 }
26190
26191
26192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26193   void * jresult ;
26194   Dali::Shader::Property *result = 0 ;
26195
26196   {
26197     try {
26198       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26199     } catch (std::out_of_range& e) {
26200       {
26201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26202       };
26203     } catch (std::exception& e) {
26204       {
26205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26206       };
26207     } catch (Dali::DaliException e) {
26208       {
26209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26210       };
26211     } catch (...) {
26212       {
26213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26214       };
26215     }
26216   }
26217
26218   jresult = (void *)result;
26219   return jresult;
26220 }
26221
26222
26223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26224   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26225
26226   arg1 = (Dali::Shader::Property *)jarg1;
26227   {
26228     try {
26229       delete arg1;
26230     } catch (std::out_of_range& e) {
26231       {
26232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26233       };
26234     } catch (std::exception& e) {
26235       {
26236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26237       };
26238     } catch (Dali::DaliException e) {
26239       {
26240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26241       };
26242     } catch (...) {
26243       {
26244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26245       };
26246     }
26247   }
26248
26249 }
26250
26251
26252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26253   void * jresult ;
26254   std::string *arg1 = 0 ;
26255   std::string *arg2 = 0 ;
26256   Dali::Shader::Hint::Value arg3 ;
26257   Dali::Shader result;
26258
26259   if (!jarg1) {
26260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26261     return 0;
26262   }
26263   std::string arg1_str(jarg1);
26264   arg1 = &arg1_str;
26265   if (!jarg2) {
26266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26267     return 0;
26268   }
26269   std::string arg2_str(jarg2);
26270   arg2 = &arg2_str;
26271   arg3 = (Dali::Shader::Hint::Value)jarg3;
26272   {
26273     try {
26274       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26275     } catch (std::out_of_range& e) {
26276       {
26277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (std::exception& e) {
26280       {
26281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (Dali::DaliException e) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26286       };
26287     } catch (...) {
26288       {
26289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26290       };
26291     }
26292   }
26293
26294   jresult = new Dali::Shader((const Dali::Shader &)result);
26295
26296   //argout typemap for const std::string&
26297
26298
26299   //argout typemap for const std::string&
26300
26301   return jresult;
26302 }
26303
26304
26305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26306   void * jresult ;
26307   std::string *arg1 = 0 ;
26308   std::string *arg2 = 0 ;
26309   Dali::Shader result;
26310
26311   if (!jarg1) {
26312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26313     return 0;
26314   }
26315   std::string arg1_str(jarg1);
26316   arg1 = &arg1_str;
26317   if (!jarg2) {
26318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26319     return 0;
26320   }
26321   std::string arg2_str(jarg2);
26322   arg2 = &arg2_str;
26323   {
26324     try {
26325       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26326     } catch (std::out_of_range& e) {
26327       {
26328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26329       };
26330     } catch (std::exception& e) {
26331       {
26332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26333       };
26334     } catch (Dali::DaliException e) {
26335       {
26336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26337       };
26338     } catch (...) {
26339       {
26340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26341       };
26342     }
26343   }
26344
26345   jresult = new Dali::Shader((const Dali::Shader &)result);
26346
26347   //argout typemap for const std::string&
26348
26349
26350   //argout typemap for const std::string&
26351
26352   return jresult;
26353 }
26354
26355
26356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26357   void * jresult ;
26358   Dali::Shader *result = 0 ;
26359
26360   {
26361     try {
26362       result = (Dali::Shader *)new Dali::Shader();
26363     } catch (std::out_of_range& e) {
26364       {
26365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (std::exception& e) {
26368       {
26369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26370       };
26371     } catch (Dali::DaliException e) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26374       };
26375     } catch (...) {
26376       {
26377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26378       };
26379     }
26380   }
26381
26382   jresult = (void *)result;
26383   return jresult;
26384 }
26385
26386
26387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26388   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26389
26390   arg1 = (Dali::Shader *)jarg1;
26391   {
26392     try {
26393       delete arg1;
26394     } catch (std::out_of_range& e) {
26395       {
26396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26397       };
26398     } catch (std::exception& e) {
26399       {
26400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26401       };
26402     } catch (Dali::DaliException e) {
26403       {
26404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26405       };
26406     } catch (...) {
26407       {
26408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26409       };
26410     }
26411   }
26412
26413 }
26414
26415
26416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26417   void * jresult ;
26418   Dali::Shader *arg1 = 0 ;
26419   Dali::Shader *result = 0 ;
26420
26421   arg1 = (Dali::Shader *)jarg1;
26422   if (!arg1) {
26423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26424     return 0;
26425   }
26426   {
26427     try {
26428       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26429     } catch (std::out_of_range& e) {
26430       {
26431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (std::exception& e) {
26434       {
26435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (Dali::DaliException e) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26440       };
26441     } catch (...) {
26442       {
26443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26444       };
26445     }
26446   }
26447
26448   jresult = (void *)result;
26449   return jresult;
26450 }
26451
26452
26453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26454   void * jresult ;
26455   Dali::BaseHandle arg1 ;
26456   Dali::BaseHandle *argp1 ;
26457   Dali::Shader result;
26458
26459   argp1 = (Dali::BaseHandle *)jarg1;
26460   if (!argp1) {
26461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26462     return 0;
26463   }
26464   arg1 = *argp1;
26465   {
26466     try {
26467       result = Dali::Shader::DownCast(arg1);
26468     } catch (std::out_of_range& e) {
26469       {
26470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26471       };
26472     } catch (std::exception& e) {
26473       {
26474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26475       };
26476     } catch (Dali::DaliException e) {
26477       {
26478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26479       };
26480     } catch (...) {
26481       {
26482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26483       };
26484     }
26485   }
26486
26487   jresult = new Dali::Shader((const Dali::Shader &)result);
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26493   void * jresult ;
26494   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26495   Dali::Shader *arg2 = 0 ;
26496   Dali::Shader *result = 0 ;
26497
26498   arg1 = (Dali::Shader *)jarg1;
26499   arg2 = (Dali::Shader *)jarg2;
26500   if (!arg2) {
26501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26502     return 0;
26503   }
26504   {
26505     try {
26506       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26507     } catch (std::out_of_range& e) {
26508       {
26509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26510       };
26511     } catch (std::exception& e) {
26512       {
26513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26514       };
26515     } catch (Dali::DaliException e) {
26516       {
26517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26518       };
26519     } catch (...) {
26520       {
26521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26522       };
26523     }
26524   }
26525
26526   jresult = (void *)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26532   int jresult ;
26533   int result;
26534
26535   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26536   jresult = (int)result;
26537   return jresult;
26538 }
26539
26540
26541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26542   int jresult ;
26543   int result;
26544
26545   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26546   jresult = (int)result;
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26552   int jresult ;
26553   int result;
26554
26555   result = (int)Dali::Renderer::Property::BLEND_MODE;
26556   jresult = (int)result;
26557   return jresult;
26558 }
26559
26560
26561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26562   int jresult ;
26563   int result;
26564
26565   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26566   jresult = (int)result;
26567   return jresult;
26568 }
26569
26570
26571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26572   int jresult ;
26573   int result;
26574
26575   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26576   jresult = (int)result;
26577   return jresult;
26578 }
26579
26580
26581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26582   int jresult ;
26583   int result;
26584
26585   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26586   jresult = (int)result;
26587   return jresult;
26588 }
26589
26590
26591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26592   int jresult ;
26593   int result;
26594
26595   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26596   jresult = (int)result;
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26602   int jresult ;
26603   int result;
26604
26605   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26606   jresult = (int)result;
26607   return jresult;
26608 }
26609
26610
26611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26612   int jresult ;
26613   int result;
26614
26615   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26616   jresult = (int)result;
26617   return jresult;
26618 }
26619
26620
26621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26622   int jresult ;
26623   int result;
26624
26625   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26626   jresult = (int)result;
26627   return jresult;
26628 }
26629
26630
26631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26632   int jresult ;
26633   int result;
26634
26635   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26636   jresult = (int)result;
26637   return jresult;
26638 }
26639
26640
26641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26642   int jresult ;
26643   int result;
26644
26645   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26646   jresult = (int)result;
26647   return jresult;
26648 }
26649
26650
26651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26652   int jresult ;
26653   int result;
26654
26655   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26656   jresult = (int)result;
26657   return jresult;
26658 }
26659
26660
26661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26662   int jresult ;
26663   int result;
26664
26665   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26666   jresult = (int)result;
26667   return jresult;
26668 }
26669
26670
26671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26672   int jresult ;
26673   int result;
26674
26675   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26676   jresult = (int)result;
26677   return jresult;
26678 }
26679
26680
26681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26682   int jresult ;
26683   int result;
26684
26685   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26686   jresult = (int)result;
26687   return jresult;
26688 }
26689
26690
26691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26692   int jresult ;
26693   int result;
26694
26695   result = (int)Dali::Renderer::Property::RENDER_MODE;
26696   jresult = (int)result;
26697   return jresult;
26698 }
26699
26700
26701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26702   int jresult ;
26703   int result;
26704
26705   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26706   jresult = (int)result;
26707   return jresult;
26708 }
26709
26710
26711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26712   int jresult ;
26713   int result;
26714
26715   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26716   jresult = (int)result;
26717   return jresult;
26718 }
26719
26720
26721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26722   int jresult ;
26723   int result;
26724
26725   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26726   jresult = (int)result;
26727   return jresult;
26728 }
26729
26730
26731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26732   int jresult ;
26733   int result;
26734
26735   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26736   jresult = (int)result;
26737   return jresult;
26738 }
26739
26740
26741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26742   int jresult ;
26743   int result;
26744
26745   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26746   jresult = (int)result;
26747   return jresult;
26748 }
26749
26750
26751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26752   int jresult ;
26753   int result;
26754
26755   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26756   jresult = (int)result;
26757   return jresult;
26758 }
26759
26760
26761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26762   int jresult ;
26763   int result;
26764
26765   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26766   jresult = (int)result;
26767   return jresult;
26768 }
26769
26770
26771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26772   void * jresult ;
26773   Dali::Renderer::Property *result = 0 ;
26774
26775   {
26776     try {
26777       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26778     } catch (std::out_of_range& e) {
26779       {
26780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26781       };
26782     } catch (std::exception& e) {
26783       {
26784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26785       };
26786     } catch (Dali::DaliException e) {
26787       {
26788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26789       };
26790     } catch (...) {
26791       {
26792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26793       };
26794     }
26795   }
26796
26797   jresult = (void *)result;
26798   return jresult;
26799 }
26800
26801
26802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26803   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26804
26805   arg1 = (Dali::Renderer::Property *)jarg1;
26806   {
26807     try {
26808       delete arg1;
26809     } catch (std::out_of_range& e) {
26810       {
26811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26812       };
26813     } catch (std::exception& e) {
26814       {
26815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26816       };
26817     } catch (Dali::DaliException e) {
26818       {
26819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26820       };
26821     } catch (...) {
26822       {
26823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26824       };
26825     }
26826   }
26827
26828 }
26829
26830
26831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26832   void * jresult ;
26833   Dali::Geometry *arg1 = 0 ;
26834   Dali::Shader *arg2 = 0 ;
26835   Dali::Renderer result;
26836
26837   arg1 = (Dali::Geometry *)jarg1;
26838   if (!arg1) {
26839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26840     return 0;
26841   }
26842   arg2 = (Dali::Shader *)jarg2;
26843   if (!arg2) {
26844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26845     return 0;
26846   }
26847   {
26848     try {
26849       result = Dali::Renderer::New(*arg1,*arg2);
26850     } catch (std::out_of_range& e) {
26851       {
26852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26853       };
26854     } catch (std::exception& e) {
26855       {
26856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26857       };
26858     } catch (Dali::DaliException e) {
26859       {
26860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26861       };
26862     } catch (...) {
26863       {
26864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26865       };
26866     }
26867   }
26868
26869   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26870   return jresult;
26871 }
26872
26873
26874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26875   void * jresult ;
26876   Dali::Renderer *result = 0 ;
26877
26878   {
26879     try {
26880       result = (Dali::Renderer *)new Dali::Renderer();
26881     } catch (std::out_of_range& e) {
26882       {
26883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (std::exception& e) {
26886       {
26887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26888       };
26889     } catch (Dali::DaliException e) {
26890       {
26891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26892       };
26893     } catch (...) {
26894       {
26895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26896       };
26897     }
26898   }
26899
26900   jresult = (void *)result;
26901   return jresult;
26902 }
26903
26904
26905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26906   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26907
26908   arg1 = (Dali::Renderer *)jarg1;
26909   {
26910     try {
26911       delete arg1;
26912     } catch (std::out_of_range& e) {
26913       {
26914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26915       };
26916     } catch (std::exception& e) {
26917       {
26918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26919       };
26920     } catch (Dali::DaliException e) {
26921       {
26922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26923       };
26924     } catch (...) {
26925       {
26926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26927       };
26928     }
26929   }
26930
26931 }
26932
26933
26934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26935   void * jresult ;
26936   Dali::Renderer *arg1 = 0 ;
26937   Dali::Renderer *result = 0 ;
26938
26939   arg1 = (Dali::Renderer *)jarg1;
26940   if (!arg1) {
26941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26942     return 0;
26943   }
26944   {
26945     try {
26946       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26947     } catch (std::out_of_range& e) {
26948       {
26949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26950       };
26951     } catch (std::exception& e) {
26952       {
26953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26954       };
26955     } catch (Dali::DaliException e) {
26956       {
26957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26958       };
26959     } catch (...) {
26960       {
26961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26962       };
26963     }
26964   }
26965
26966   jresult = (void *)result;
26967   return jresult;
26968 }
26969
26970
26971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26972   void * jresult ;
26973   Dali::BaseHandle arg1 ;
26974   Dali::BaseHandle *argp1 ;
26975   Dali::Renderer result;
26976
26977   argp1 = (Dali::BaseHandle *)jarg1;
26978   if (!argp1) {
26979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26980     return 0;
26981   }
26982   arg1 = *argp1;
26983   {
26984     try {
26985       result = Dali::Renderer::DownCast(arg1);
26986     } catch (std::out_of_range& e) {
26987       {
26988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26989       };
26990     } catch (std::exception& e) {
26991       {
26992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26993       };
26994     } catch (Dali::DaliException e) {
26995       {
26996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26997       };
26998     } catch (...) {
26999       {
27000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27001       };
27002     }
27003   }
27004
27005   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27006   return jresult;
27007 }
27008
27009
27010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27011   void * jresult ;
27012   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27013   Dali::Renderer *arg2 = 0 ;
27014   Dali::Renderer *result = 0 ;
27015
27016   arg1 = (Dali::Renderer *)jarg1;
27017   arg2 = (Dali::Renderer *)jarg2;
27018   if (!arg2) {
27019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27020     return 0;
27021   }
27022   {
27023     try {
27024       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27025     } catch (std::out_of_range& e) {
27026       {
27027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27028       };
27029     } catch (std::exception& e) {
27030       {
27031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27032       };
27033     } catch (Dali::DaliException e) {
27034       {
27035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27036       };
27037     } catch (...) {
27038       {
27039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27040       };
27041     }
27042   }
27043
27044   jresult = (void *)result;
27045   return jresult;
27046 }
27047
27048
27049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27050   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27051   Dali::Geometry *arg2 = 0 ;
27052
27053   arg1 = (Dali::Renderer *)jarg1;
27054   arg2 = (Dali::Geometry *)jarg2;
27055   if (!arg2) {
27056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27057     return ;
27058   }
27059   {
27060     try {
27061       (arg1)->SetGeometry(*arg2);
27062     } catch (std::out_of_range& e) {
27063       {
27064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27065       };
27066     } catch (std::exception& e) {
27067       {
27068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27069       };
27070     } catch (Dali::DaliException e) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27073       };
27074     } catch (...) {
27075       {
27076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27077       };
27078     }
27079   }
27080
27081 }
27082
27083
27084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27085   void * jresult ;
27086   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27087   Dali::Geometry result;
27088
27089   arg1 = (Dali::Renderer *)jarg1;
27090   {
27091     try {
27092       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27093     } catch (std::out_of_range& e) {
27094       {
27095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (std::exception& e) {
27098       {
27099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27100       };
27101     } catch (Dali::DaliException e) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27104       };
27105     } catch (...) {
27106       {
27107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27108       };
27109     }
27110   }
27111
27112   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27113   return jresult;
27114 }
27115
27116
27117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27118   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27119   int arg2 ;
27120   int arg3 ;
27121
27122   arg1 = (Dali::Renderer *)jarg1;
27123   arg2 = (int)jarg2;
27124   arg3 = (int)jarg3;
27125   {
27126     try {
27127       (arg1)->SetIndexRange(arg2,arg3);
27128     } catch (std::out_of_range& e) {
27129       {
27130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27131       };
27132     } catch (std::exception& e) {
27133       {
27134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27135       };
27136     } catch (Dali::DaliException e) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27139       };
27140     } catch (...) {
27141       {
27142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27143       };
27144     }
27145   }
27146
27147 }
27148
27149
27150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27151   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27152   Dali::TextureSet *arg2 = 0 ;
27153
27154   arg1 = (Dali::Renderer *)jarg1;
27155   arg2 = (Dali::TextureSet *)jarg2;
27156   if (!arg2) {
27157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27158     return ;
27159   }
27160   {
27161     try {
27162       (arg1)->SetTextures(*arg2);
27163     } catch (std::out_of_range& e) {
27164       {
27165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27166       };
27167     } catch (std::exception& e) {
27168       {
27169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27170       };
27171     } catch (Dali::DaliException e) {
27172       {
27173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27174       };
27175     } catch (...) {
27176       {
27177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27178       };
27179     }
27180   }
27181
27182 }
27183
27184
27185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27186   void * jresult ;
27187   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27188   Dali::TextureSet result;
27189
27190   arg1 = (Dali::Renderer *)jarg1;
27191   {
27192     try {
27193       result = ((Dali::Renderer const *)arg1)->GetTextures();
27194     } catch (std::out_of_range& e) {
27195       {
27196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27197       };
27198     } catch (std::exception& e) {
27199       {
27200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27201       };
27202     } catch (Dali::DaliException e) {
27203       {
27204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27205       };
27206     } catch (...) {
27207       {
27208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27209       };
27210     }
27211   }
27212
27213   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27214   return jresult;
27215 }
27216
27217
27218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27219   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27220   Dali::Shader *arg2 = 0 ;
27221
27222   arg1 = (Dali::Renderer *)jarg1;
27223   arg2 = (Dali::Shader *)jarg2;
27224   if (!arg2) {
27225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27226     return ;
27227   }
27228   {
27229     try {
27230       (arg1)->SetShader(*arg2);
27231     } catch (std::out_of_range& e) {
27232       {
27233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27234       };
27235     } catch (std::exception& e) {
27236       {
27237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27238       };
27239     } catch (Dali::DaliException e) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27242       };
27243     } catch (...) {
27244       {
27245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27246       };
27247     }
27248   }
27249
27250 }
27251
27252
27253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27254   void * jresult ;
27255   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27256   Dali::Shader result;
27257
27258   arg1 = (Dali::Renderer *)jarg1;
27259   {
27260     try {
27261       result = ((Dali::Renderer const *)arg1)->GetShader();
27262     } catch (std::out_of_range& e) {
27263       {
27264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27265       };
27266     } catch (std::exception& e) {
27267       {
27268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27269       };
27270     } catch (Dali::DaliException e) {
27271       {
27272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27273       };
27274     } catch (...) {
27275       {
27276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27277       };
27278     }
27279   }
27280
27281   jresult = new Dali::Shader((const Dali::Shader &)result);
27282   return jresult;
27283 }
27284
27285
27286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27287   void * jresult ;
27288   Dali::FrameBuffer::Attachment *result = 0 ;
27289
27290   {
27291     try {
27292       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27293     } catch (std::out_of_range& e) {
27294       {
27295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (std::exception& e) {
27298       {
27299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27300       };
27301     } catch (Dali::DaliException e) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27304       };
27305     } catch (...) {
27306       {
27307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27308       };
27309     }
27310   }
27311
27312   jresult = (void *)result;
27313   return jresult;
27314 }
27315
27316
27317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27318   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27319
27320   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27321   {
27322     try {
27323       delete arg1;
27324     } catch (std::out_of_range& e) {
27325       {
27326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27327       };
27328     } catch (std::exception& e) {
27329       {
27330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27331       };
27332     } catch (Dali::DaliException e) {
27333       {
27334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27335       };
27336     } catch (...) {
27337       {
27338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27339       };
27340     }
27341   }
27342
27343 }
27344
27345
27346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27347   void * jresult ;
27348   unsigned int arg1 ;
27349   unsigned int arg2 ;
27350   unsigned int arg3 ;
27351   Dali::FrameBuffer result;
27352
27353   arg1 = (unsigned int)jarg1;
27354   arg2 = (unsigned int)jarg2;
27355   arg3 = (unsigned int)jarg3;
27356   {
27357     try {
27358       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27359     } catch (std::out_of_range& e) {
27360       {
27361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27362       };
27363     } catch (std::exception& e) {
27364       {
27365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27366       };
27367     } catch (Dali::DaliException e) {
27368       {
27369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27370       };
27371     } catch (...) {
27372       {
27373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27374       };
27375     }
27376   }
27377
27378   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27379   return jresult;
27380 }
27381
27382
27383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27384   void * jresult ;
27385   Dali::FrameBuffer *result = 0 ;
27386
27387   {
27388     try {
27389       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27390     } catch (std::out_of_range& e) {
27391       {
27392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27393       };
27394     } catch (std::exception& e) {
27395       {
27396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27397       };
27398     } catch (Dali::DaliException e) {
27399       {
27400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27401       };
27402     } catch (...) {
27403       {
27404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27405       };
27406     }
27407   }
27408
27409   jresult = (void *)result;
27410   return jresult;
27411 }
27412
27413
27414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27415   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27416
27417   arg1 = (Dali::FrameBuffer *)jarg1;
27418   {
27419     try {
27420       delete arg1;
27421     } catch (std::out_of_range& e) {
27422       {
27423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27424       };
27425     } catch (std::exception& e) {
27426       {
27427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27428       };
27429     } catch (Dali::DaliException e) {
27430       {
27431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27432       };
27433     } catch (...) {
27434       {
27435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27436       };
27437     }
27438   }
27439
27440 }
27441
27442
27443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27444   void * jresult ;
27445   Dali::FrameBuffer *arg1 = 0 ;
27446   Dali::FrameBuffer *result = 0 ;
27447
27448   arg1 = (Dali::FrameBuffer *)jarg1;
27449   if (!arg1) {
27450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27451     return 0;
27452   }
27453   {
27454     try {
27455       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27456     } catch (std::out_of_range& e) {
27457       {
27458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27459       };
27460     } catch (std::exception& e) {
27461       {
27462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27463       };
27464     } catch (Dali::DaliException e) {
27465       {
27466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27467       };
27468     } catch (...) {
27469       {
27470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27471       };
27472     }
27473   }
27474
27475   jresult = (void *)result;
27476   return jresult;
27477 }
27478
27479
27480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27481   void * jresult ;
27482   Dali::BaseHandle arg1 ;
27483   Dali::BaseHandle *argp1 ;
27484   Dali::FrameBuffer result;
27485
27486   argp1 = (Dali::BaseHandle *)jarg1;
27487   if (!argp1) {
27488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27489     return 0;
27490   }
27491   arg1 = *argp1;
27492   {
27493     try {
27494       result = Dali::FrameBuffer::DownCast(arg1);
27495     } catch (std::out_of_range& e) {
27496       {
27497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27498       };
27499     } catch (std::exception& e) {
27500       {
27501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27502       };
27503     } catch (Dali::DaliException e) {
27504       {
27505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27506       };
27507     } catch (...) {
27508       {
27509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27510       };
27511     }
27512   }
27513
27514   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27515   return jresult;
27516 }
27517
27518
27519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27520   void * jresult ;
27521   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27522   Dali::FrameBuffer *arg2 = 0 ;
27523   Dali::FrameBuffer *result = 0 ;
27524
27525   arg1 = (Dali::FrameBuffer *)jarg1;
27526   arg2 = (Dali::FrameBuffer *)jarg2;
27527   if (!arg2) {
27528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27529     return 0;
27530   }
27531   {
27532     try {
27533       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27534     } catch (std::out_of_range& e) {
27535       {
27536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27537       };
27538     } catch (std::exception& e) {
27539       {
27540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27541       };
27542     } catch (Dali::DaliException e) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27545       };
27546     } catch (...) {
27547       {
27548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27549       };
27550     }
27551   }
27552
27553   jresult = (void *)result;
27554   return jresult;
27555 }
27556
27557
27558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27559   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27560   Dali::Texture *arg2 = 0 ;
27561
27562   arg1 = (Dali::FrameBuffer *)jarg1;
27563   arg2 = (Dali::Texture *)jarg2;
27564   if (!arg2) {
27565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27566     return ;
27567   }
27568   {
27569     try {
27570       (arg1)->AttachColorTexture(*arg2);
27571     } catch (std::out_of_range& e) {
27572       {
27573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27574       };
27575     } catch (std::exception& e) {
27576       {
27577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27578       };
27579     } catch (Dali::DaliException e) {
27580       {
27581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27582       };
27583     } catch (...) {
27584       {
27585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27586       };
27587     }
27588   }
27589
27590 }
27591
27592
27593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27594   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27595   Dali::Texture *arg2 = 0 ;
27596   unsigned int arg3 ;
27597   unsigned int arg4 ;
27598
27599   arg1 = (Dali::FrameBuffer *)jarg1;
27600   arg2 = (Dali::Texture *)jarg2;
27601   if (!arg2) {
27602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27603     return ;
27604   }
27605   arg3 = (unsigned int)jarg3;
27606   arg4 = (unsigned int)jarg4;
27607   {
27608     try {
27609       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27610     } catch (std::out_of_range& e) {
27611       {
27612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27613       };
27614     } catch (std::exception& e) {
27615       {
27616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27617       };
27618     } catch (Dali::DaliException e) {
27619       {
27620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27621       };
27622     } catch (...) {
27623       {
27624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27625       };
27626     }
27627   }
27628
27629 }
27630
27631
27632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27633   void * jresult ;
27634   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27635   Dali::Texture result;
27636
27637   arg1 = (Dali::FrameBuffer *)jarg1;
27638   {
27639     try {
27640       result = (arg1)->GetColorTexture();
27641     } catch (std::out_of_range& e) {
27642       {
27643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27644       };
27645     } catch (std::exception& e) {
27646       {
27647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27648       };
27649     } catch (Dali::DaliException e) {
27650       {
27651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27652       };
27653     } catch (...) {
27654       {
27655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27656       };
27657     }
27658   }
27659
27660   jresult = new Dali::Texture((const Dali::Texture &)result);
27661   return jresult;
27662 }
27663
27664
27665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27666   void * jresult ;
27667   Dali::RenderTaskList *result = 0 ;
27668
27669   {
27670     try {
27671       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27672     } catch (std::out_of_range& e) {
27673       {
27674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27675       };
27676     } catch (std::exception& e) {
27677       {
27678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27679       };
27680     } catch (Dali::DaliException e) {
27681       {
27682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27683       };
27684     } catch (...) {
27685       {
27686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27687       };
27688     }
27689   }
27690
27691   jresult = (void *)result;
27692   return jresult;
27693 }
27694
27695
27696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27697   void * jresult ;
27698   Dali::BaseHandle arg1 ;
27699   Dali::BaseHandle *argp1 ;
27700   Dali::RenderTaskList result;
27701
27702   argp1 = (Dali::BaseHandle *)jarg1;
27703   if (!argp1) {
27704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27705     return 0;
27706   }
27707   arg1 = *argp1;
27708   {
27709     try {
27710       result = Dali::RenderTaskList::DownCast(arg1);
27711     } catch (std::out_of_range& e) {
27712       {
27713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27714       };
27715     } catch (std::exception& e) {
27716       {
27717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27718       };
27719     } catch (Dali::DaliException e) {
27720       {
27721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27722       };
27723     } catch (...) {
27724       {
27725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27726       };
27727     }
27728   }
27729
27730   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27731   return jresult;
27732 }
27733
27734
27735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27736   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27737
27738   arg1 = (Dali::RenderTaskList *)jarg1;
27739   {
27740     try {
27741       delete arg1;
27742     } catch (std::out_of_range& e) {
27743       {
27744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27745       };
27746     } catch (std::exception& e) {
27747       {
27748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27749       };
27750     } catch (Dali::DaliException e) {
27751       {
27752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27753       };
27754     } catch (...) {
27755       {
27756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27757       };
27758     }
27759   }
27760
27761 }
27762
27763
27764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27765   void * jresult ;
27766   Dali::RenderTaskList *arg1 = 0 ;
27767   Dali::RenderTaskList *result = 0 ;
27768
27769   arg1 = (Dali::RenderTaskList *)jarg1;
27770   if (!arg1) {
27771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27772     return 0;
27773   }
27774   {
27775     try {
27776       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27777     } catch (std::out_of_range& e) {
27778       {
27779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (std::exception& e) {
27782       {
27783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27784       };
27785     } catch (Dali::DaliException e) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27788       };
27789     } catch (...) {
27790       {
27791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27792       };
27793     }
27794   }
27795
27796   jresult = (void *)result;
27797   return jresult;
27798 }
27799
27800
27801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27802   void * jresult ;
27803   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27804   Dali::RenderTaskList *arg2 = 0 ;
27805   Dali::RenderTaskList *result = 0 ;
27806
27807   arg1 = (Dali::RenderTaskList *)jarg1;
27808   arg2 = (Dali::RenderTaskList *)jarg2;
27809   if (!arg2) {
27810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27811     return 0;
27812   }
27813   {
27814     try {
27815       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27816     } catch (std::out_of_range& e) {
27817       {
27818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27819       };
27820     } catch (std::exception& e) {
27821       {
27822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27823       };
27824     } catch (Dali::DaliException e) {
27825       {
27826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27827       };
27828     } catch (...) {
27829       {
27830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27831       };
27832     }
27833   }
27834
27835   jresult = (void *)result;
27836   return jresult;
27837 }
27838
27839
27840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27841   void * jresult ;
27842   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27843   Dali::RenderTask result;
27844
27845   arg1 = (Dali::RenderTaskList *)jarg1;
27846   {
27847     try {
27848       result = (arg1)->CreateTask();
27849     } catch (std::out_of_range& e) {
27850       {
27851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (std::exception& e) {
27854       {
27855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27856       };
27857     } catch (Dali::DaliException e) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27860       };
27861     } catch (...) {
27862       {
27863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27864       };
27865     }
27866   }
27867
27868   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27869   return jresult;
27870 }
27871
27872
27873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27874   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27875   Dali::RenderTask arg2 ;
27876   Dali::RenderTask *argp2 ;
27877
27878   arg1 = (Dali::RenderTaskList *)jarg1;
27879   argp2 = (Dali::RenderTask *)jarg2;
27880   if (!argp2) {
27881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27882     return ;
27883   }
27884   arg2 = *argp2;
27885   {
27886     try {
27887       (arg1)->RemoveTask(arg2);
27888     } catch (std::out_of_range& e) {
27889       {
27890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27891       };
27892     } catch (std::exception& e) {
27893       {
27894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27895       };
27896     } catch (Dali::DaliException e) {
27897       {
27898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27899       };
27900     } catch (...) {
27901       {
27902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27903       };
27904     }
27905   }
27906
27907 }
27908
27909
27910 //// ===============================================end part 1 =================
27911
27912 //// ========================= part 2 ===============================
27913
27914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27915   unsigned int jresult ;
27916   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27917   unsigned int result;
27918
27919   arg1 = (Dali::RenderTaskList *)jarg1;
27920   {
27921     try {
27922       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27923     } catch (std::out_of_range& e) {
27924       {
27925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (std::exception& e) {
27928       {
27929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27930       };
27931     } catch (Dali::DaliException e) {
27932       {
27933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27934       };
27935     } catch (...) {
27936       {
27937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27938       };
27939     }
27940   }
27941
27942   jresult = result;
27943   return jresult;
27944 }
27945
27946
27947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27948   void * jresult ;
27949   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27950   unsigned int arg2 ;
27951   Dali::RenderTask result;
27952
27953   arg1 = (Dali::RenderTaskList *)jarg1;
27954   arg2 = (unsigned int)jarg2;
27955   {
27956     try {
27957       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27958     } catch (std::out_of_range& e) {
27959       {
27960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27961       };
27962     } catch (std::exception& e) {
27963       {
27964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27965       };
27966     } catch (Dali::DaliException e) {
27967       {
27968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27969       };
27970     } catch (...) {
27971       {
27972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27973       };
27974     }
27975   }
27976
27977   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27978   return jresult;
27979 }
27980
27981
27982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27983   int jresult ;
27984   int result;
27985
27986   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27987   jresult = (int)result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27993   int jresult ;
27994   int result;
27995
27996   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27997   jresult = (int)result;
27998   return jresult;
27999 }
28000
28001
28002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28003   int jresult ;
28004   int result;
28005
28006   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28007   jresult = (int)result;
28008   return jresult;
28009 }
28010
28011
28012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28013   int jresult ;
28014   int result;
28015
28016   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28017   jresult = (int)result;
28018   return jresult;
28019 }
28020
28021
28022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28023   void * jresult ;
28024   Dali::RenderTask::Property *result = 0 ;
28025
28026   {
28027     try {
28028       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28029     } catch (std::out_of_range& e) {
28030       {
28031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28032       };
28033     } catch (std::exception& e) {
28034       {
28035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28036       };
28037     } catch (Dali::DaliException e) {
28038       {
28039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28040       };
28041     } catch (...) {
28042       {
28043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28044       };
28045     }
28046   }
28047
28048   jresult = (void *)result;
28049   return jresult;
28050 }
28051
28052
28053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28054   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28055
28056   arg1 = (Dali::RenderTask::Property *)jarg1;
28057   {
28058     try {
28059       delete arg1;
28060     } catch (std::out_of_range& e) {
28061       {
28062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28063       };
28064     } catch (std::exception& e) {
28065       {
28066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28067       };
28068     } catch (Dali::DaliException e) {
28069       {
28070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28071       };
28072     } catch (...) {
28073       {
28074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28075       };
28076     }
28077   }
28078
28079 }
28080
28081
28082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28083   void * jresult ;
28084   bool (*result)(Dali::Vector2 &) = 0 ;
28085
28086   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28087   jresult = (void *)result;
28088   return jresult;
28089 }
28090
28091
28092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28093   void * jresult ;
28094   bool (*result)(Dali::Vector2 &) = 0 ;
28095
28096   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28097   jresult = (void *)result;
28098   return jresult;
28099 }
28100
28101
28102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28103   unsigned int jresult ;
28104   bool result;
28105
28106   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28107   jresult = result;
28108   return jresult;
28109 }
28110
28111
28112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28113   unsigned int jresult ;
28114   bool result;
28115
28116   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28117   jresult = result;
28118   return jresult;
28119 }
28120
28121
28122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28123   void * jresult ;
28124   Dali::Vector4 *result = 0 ;
28125
28126   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28127   jresult = (void *)result;
28128   return jresult;
28129 }
28130
28131
28132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28133   unsigned int jresult ;
28134   bool result;
28135
28136   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28137   jresult = result;
28138   return jresult;
28139 }
28140
28141
28142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28143   unsigned int jresult ;
28144   bool result;
28145
28146   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28147   jresult = result;
28148   return jresult;
28149 }
28150
28151
28152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28153   unsigned int jresult ;
28154   unsigned int result;
28155
28156   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28157   jresult = result;
28158   return jresult;
28159 }
28160
28161
28162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28163   void * jresult ;
28164   Dali::RenderTask *result = 0 ;
28165
28166   {
28167     try {
28168       result = (Dali::RenderTask *)new Dali::RenderTask();
28169     } catch (std::out_of_range& e) {
28170       {
28171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28172       };
28173     } catch (std::exception& e) {
28174       {
28175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28176       };
28177     } catch (Dali::DaliException e) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28180       };
28181     } catch (...) {
28182       {
28183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28184       };
28185     }
28186   }
28187
28188   jresult = (void *)result;
28189   return jresult;
28190 }
28191
28192
28193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28194   void * jresult ;
28195   Dali::BaseHandle arg1 ;
28196   Dali::BaseHandle *argp1 ;
28197   Dali::RenderTask result;
28198
28199   argp1 = (Dali::BaseHandle *)jarg1;
28200   if (!argp1) {
28201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28202     return 0;
28203   }
28204   arg1 = *argp1;
28205   {
28206     try {
28207       result = Dali::RenderTask::DownCast(arg1);
28208     } catch (std::out_of_range& e) {
28209       {
28210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28211       };
28212     } catch (std::exception& e) {
28213       {
28214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28215       };
28216     } catch (Dali::DaliException e) {
28217       {
28218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28219       };
28220     } catch (...) {
28221       {
28222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28223       };
28224     }
28225   }
28226
28227   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28228   return jresult;
28229 }
28230
28231
28232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28233   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28234
28235   arg1 = (Dali::RenderTask *)jarg1;
28236   {
28237     try {
28238       delete arg1;
28239     } catch (std::out_of_range& e) {
28240       {
28241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28242       };
28243     } catch (std::exception& e) {
28244       {
28245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28246       };
28247     } catch (Dali::DaliException e) {
28248       {
28249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28250       };
28251     } catch (...) {
28252       {
28253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28254       };
28255     }
28256   }
28257
28258 }
28259
28260
28261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28262   void * jresult ;
28263   Dali::RenderTask *arg1 = 0 ;
28264   Dali::RenderTask *result = 0 ;
28265
28266   arg1 = (Dali::RenderTask *)jarg1;
28267   if (!arg1) {
28268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28269     return 0;
28270   }
28271   {
28272     try {
28273       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28274     } catch (std::out_of_range& e) {
28275       {
28276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28277       };
28278     } catch (std::exception& e) {
28279       {
28280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28281       };
28282     } catch (Dali::DaliException e) {
28283       {
28284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28285       };
28286     } catch (...) {
28287       {
28288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28289       };
28290     }
28291   }
28292
28293   jresult = (void *)result;
28294   return jresult;
28295 }
28296
28297
28298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28299   void * jresult ;
28300   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28301   Dali::RenderTask *arg2 = 0 ;
28302   Dali::RenderTask *result = 0 ;
28303
28304   arg1 = (Dali::RenderTask *)jarg1;
28305   arg2 = (Dali::RenderTask *)jarg2;
28306   if (!arg2) {
28307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28308     return 0;
28309   }
28310   {
28311     try {
28312       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28313     } catch (std::out_of_range& e) {
28314       {
28315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28316       };
28317     } catch (std::exception& e) {
28318       {
28319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28320       };
28321     } catch (Dali::DaliException e) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28324       };
28325     } catch (...) {
28326       {
28327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28328       };
28329     }
28330   }
28331
28332   jresult = (void *)result;
28333   return jresult;
28334 }
28335
28336
28337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28338   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28339   Dali::Actor arg2 ;
28340   Dali::Actor *argp2 ;
28341
28342   arg1 = (Dali::RenderTask *)jarg1;
28343   argp2 = (Dali::Actor *)jarg2;
28344   if (!argp2) {
28345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28346     return ;
28347   }
28348   arg2 = *argp2;
28349   {
28350     try {
28351       (arg1)->SetSourceActor(arg2);
28352     } catch (std::out_of_range& e) {
28353       {
28354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28355       };
28356     } catch (std::exception& e) {
28357       {
28358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28359       };
28360     } catch (Dali::DaliException e) {
28361       {
28362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28363       };
28364     } catch (...) {
28365       {
28366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28367       };
28368     }
28369   }
28370
28371 }
28372
28373
28374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28375   void * jresult ;
28376   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28377   Dali::Actor result;
28378
28379   arg1 = (Dali::RenderTask *)jarg1;
28380   {
28381     try {
28382       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28383     } catch (std::out_of_range& e) {
28384       {
28385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28386       };
28387     } catch (std::exception& e) {
28388       {
28389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28390       };
28391     } catch (Dali::DaliException e) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28394       };
28395     } catch (...) {
28396       {
28397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28398       };
28399     }
28400   }
28401
28402   jresult = new Dali::Actor((const Dali::Actor &)result);
28403   return jresult;
28404 }
28405
28406
28407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28408   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28409   bool arg2 ;
28410
28411   arg1 = (Dali::RenderTask *)jarg1;
28412   arg2 = jarg2 ? true : false;
28413   {
28414     try {
28415       (arg1)->SetExclusive(arg2);
28416     } catch (std::out_of_range& e) {
28417       {
28418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28419       };
28420     } catch (std::exception& e) {
28421       {
28422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28423       };
28424     } catch (Dali::DaliException e) {
28425       {
28426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28427       };
28428     } catch (...) {
28429       {
28430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28431       };
28432     }
28433   }
28434
28435 }
28436
28437
28438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28439   unsigned int jresult ;
28440   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28441   bool result;
28442
28443   arg1 = (Dali::RenderTask *)jarg1;
28444   {
28445     try {
28446       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28447     } catch (std::out_of_range& e) {
28448       {
28449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28450       };
28451     } catch (std::exception& e) {
28452       {
28453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28454       };
28455     } catch (Dali::DaliException e) {
28456       {
28457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28458       };
28459     } catch (...) {
28460       {
28461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28462       };
28463     }
28464   }
28465
28466   jresult = result;
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28473   bool arg2 ;
28474
28475   arg1 = (Dali::RenderTask *)jarg1;
28476   arg2 = jarg2 ? true : false;
28477   {
28478     try {
28479       (arg1)->SetInputEnabled(arg2);
28480     } catch (std::out_of_range& e) {
28481       {
28482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28483       };
28484     } catch (std::exception& e) {
28485       {
28486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28487       };
28488     } catch (Dali::DaliException e) {
28489       {
28490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28491       };
28492     } catch (...) {
28493       {
28494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28495       };
28496     }
28497   }
28498
28499 }
28500
28501
28502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28503   unsigned int jresult ;
28504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28505   bool result;
28506
28507   arg1 = (Dali::RenderTask *)jarg1;
28508   {
28509     try {
28510       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28511     } catch (std::out_of_range& e) {
28512       {
28513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28514       };
28515     } catch (std::exception& e) {
28516       {
28517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28518       };
28519     } catch (Dali::DaliException e) {
28520       {
28521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28522       };
28523     } catch (...) {
28524       {
28525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28526       };
28527     }
28528   }
28529
28530   jresult = result;
28531   return jresult;
28532 }
28533
28534
28535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28536   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28537   Dali::CameraActor arg2 ;
28538   Dali::CameraActor *argp2 ;
28539
28540   arg1 = (Dali::RenderTask *)jarg1;
28541   argp2 = (Dali::CameraActor *)jarg2;
28542   if (!argp2) {
28543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28544     return ;
28545   }
28546   arg2 = *argp2;
28547   {
28548     try {
28549       (arg1)->SetCameraActor(arg2);
28550     } catch (std::out_of_range& e) {
28551       {
28552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28553       };
28554     } catch (std::exception& e) {
28555       {
28556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28557       };
28558     } catch (Dali::DaliException e) {
28559       {
28560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28561       };
28562     } catch (...) {
28563       {
28564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28565       };
28566     }
28567   }
28568
28569 }
28570
28571
28572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28573   void * jresult ;
28574   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28575   Dali::CameraActor result;
28576
28577   arg1 = (Dali::RenderTask *)jarg1;
28578   {
28579     try {
28580       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28581     } catch (std::out_of_range& e) {
28582       {
28583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28584       };
28585     } catch (std::exception& e) {
28586       {
28587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28588       };
28589     } catch (Dali::DaliException e) {
28590       {
28591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28592       };
28593     } catch (...) {
28594       {
28595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28596       };
28597     }
28598   }
28599
28600   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28601   return jresult;
28602 }
28603
28604
28605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28606   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28607   Dali::FrameBufferImage arg2 ;
28608   Dali::FrameBufferImage *argp2 ;
28609
28610   arg1 = (Dali::RenderTask *)jarg1;
28611   argp2 = (Dali::FrameBufferImage *)jarg2;
28612   if (!argp2) {
28613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28614     return ;
28615   }
28616   arg2 = *argp2;
28617   {
28618     try {
28619       (arg1)->SetTargetFrameBuffer(arg2);
28620     } catch (std::out_of_range& e) {
28621       {
28622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28623       };
28624     } catch (std::exception& e) {
28625       {
28626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28627       };
28628     } catch (Dali::DaliException e) {
28629       {
28630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28631       };
28632     } catch (...) {
28633       {
28634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28635       };
28636     }
28637   }
28638
28639 }
28640
28641
28642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28643   void * jresult ;
28644   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28645   Dali::FrameBufferImage result;
28646
28647   arg1 = (Dali::RenderTask *)jarg1;
28648   {
28649     try {
28650       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28651     } catch (std::out_of_range& e) {
28652       {
28653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28654       };
28655     } catch (std::exception& e) {
28656       {
28657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28658       };
28659     } catch (Dali::DaliException e) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28662       };
28663     } catch (...) {
28664       {
28665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28666       };
28667     }
28668   }
28669
28670   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28671   return jresult;
28672 }
28673
28674
28675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28676   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28677   Dali::FrameBuffer arg2 ;
28678   Dali::FrameBuffer *argp2 ;
28679
28680   arg1 = (Dali::RenderTask *)jarg1;
28681   argp2 = (Dali::FrameBuffer *)jarg2;
28682   if (!argp2) {
28683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28684     return ;
28685   }
28686   arg2 = *argp2;
28687   {
28688     try {
28689       (arg1)->SetFrameBuffer(arg2);
28690     } catch (std::out_of_range& e) {
28691       {
28692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28693       };
28694     } catch (std::exception& e) {
28695       {
28696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28697       };
28698     } catch (Dali::DaliException e) {
28699       {
28700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28701       };
28702     } catch (...) {
28703       {
28704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28705       };
28706     }
28707   }
28708
28709 }
28710
28711
28712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28713   void * jresult ;
28714   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28715   Dali::FrameBuffer result;
28716
28717   arg1 = (Dali::RenderTask *)jarg1;
28718   {
28719     try {
28720       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28721     } catch (std::out_of_range& e) {
28722       {
28723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28724       };
28725     } catch (std::exception& e) {
28726       {
28727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28728       };
28729     } catch (Dali::DaliException e) {
28730       {
28731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28732       };
28733     } catch (...) {
28734       {
28735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28736       };
28737     }
28738   }
28739
28740   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28741   return jresult;
28742 }
28743
28744
28745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28746   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28747   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28748
28749   arg1 = (Dali::RenderTask *)jarg1;
28750   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28751   {
28752     try {
28753       (arg1)->SetScreenToFrameBufferFunction(arg2);
28754     } catch (std::out_of_range& e) {
28755       {
28756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28757       };
28758     } catch (std::exception& e) {
28759       {
28760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28761       };
28762     } catch (Dali::DaliException e) {
28763       {
28764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28765       };
28766     } catch (...) {
28767       {
28768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28769       };
28770     }
28771   }
28772
28773 }
28774
28775
28776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28777   void * jresult ;
28778   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28779   Dali::RenderTask::ScreenToFrameBufferFunction result;
28780
28781   arg1 = (Dali::RenderTask *)jarg1;
28782   {
28783     try {
28784       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28785     } catch (std::out_of_range& e) {
28786       {
28787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28788       };
28789     } catch (std::exception& e) {
28790       {
28791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28792       };
28793     } catch (Dali::DaliException e) {
28794       {
28795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28796       };
28797     } catch (...) {
28798       {
28799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28800       };
28801     }
28802   }
28803
28804   jresult = (void *)result;
28805   return jresult;
28806 }
28807
28808
28809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28810   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28811   Dali::Actor arg2 ;
28812   Dali::Actor *argp2 ;
28813
28814   arg1 = (Dali::RenderTask *)jarg1;
28815   argp2 = (Dali::Actor *)jarg2;
28816   if (!argp2) {
28817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28818     return ;
28819   }
28820   arg2 = *argp2;
28821   {
28822     try {
28823       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28824     } catch (std::out_of_range& e) {
28825       {
28826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28827       };
28828     } catch (std::exception& e) {
28829       {
28830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28831       };
28832     } catch (Dali::DaliException e) {
28833       {
28834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28835       };
28836     } catch (...) {
28837       {
28838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28839       };
28840     }
28841   }
28842
28843 }
28844
28845
28846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28847   void * jresult ;
28848   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28849   Dali::Actor result;
28850
28851   arg1 = (Dali::RenderTask *)jarg1;
28852   {
28853     try {
28854       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28855     } catch (std::out_of_range& e) {
28856       {
28857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28858       };
28859     } catch (std::exception& e) {
28860       {
28861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28862       };
28863     } catch (Dali::DaliException e) {
28864       {
28865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28866       };
28867     } catch (...) {
28868       {
28869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28870       };
28871     }
28872   }
28873
28874   jresult = new Dali::Actor((const Dali::Actor &)result);
28875   return jresult;
28876 }
28877
28878
28879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28880   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28881   Dali::Vector2 arg2 ;
28882   Dali::Vector2 *argp2 ;
28883
28884   arg1 = (Dali::RenderTask *)jarg1;
28885   argp2 = (Dali::Vector2 *)jarg2;
28886   if (!argp2) {
28887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28888     return ;
28889   }
28890   arg2 = *argp2;
28891   {
28892     try {
28893       (arg1)->SetViewportPosition(arg2);
28894     } catch (std::out_of_range& e) {
28895       {
28896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28897       };
28898     } catch (std::exception& e) {
28899       {
28900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28901       };
28902     } catch (Dali::DaliException e) {
28903       {
28904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28905       };
28906     } catch (...) {
28907       {
28908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28909       };
28910     }
28911   }
28912
28913 }
28914
28915
28916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28917   void * jresult ;
28918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28919   Dali::Vector2 result;
28920
28921   arg1 = (Dali::RenderTask *)jarg1;
28922   {
28923     try {
28924       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28925     } catch (std::out_of_range& e) {
28926       {
28927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28928       };
28929     } catch (std::exception& e) {
28930       {
28931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28932       };
28933     } catch (Dali::DaliException e) {
28934       {
28935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28936       };
28937     } catch (...) {
28938       {
28939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28940       };
28941     }
28942   }
28943
28944   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28945   return jresult;
28946 }
28947
28948
28949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28951   Dali::Vector2 arg2 ;
28952   Dali::Vector2 *argp2 ;
28953
28954   arg1 = (Dali::RenderTask *)jarg1;
28955   argp2 = (Dali::Vector2 *)jarg2;
28956   if (!argp2) {
28957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28958     return ;
28959   }
28960   arg2 = *argp2;
28961   {
28962     try {
28963       (arg1)->SetViewportSize(arg2);
28964     } catch (std::out_of_range& e) {
28965       {
28966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28967       };
28968     } catch (std::exception& e) {
28969       {
28970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28971       };
28972     } catch (Dali::DaliException e) {
28973       {
28974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28975       };
28976     } catch (...) {
28977       {
28978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28979       };
28980     }
28981   }
28982
28983 }
28984
28985
28986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28987   void * jresult ;
28988   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28989   Dali::Vector2 result;
28990
28991   arg1 = (Dali::RenderTask *)jarg1;
28992   {
28993     try {
28994       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28995     } catch (std::out_of_range& e) {
28996       {
28997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28998       };
28999     } catch (std::exception& e) {
29000       {
29001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29002       };
29003     } catch (Dali::DaliException e) {
29004       {
29005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29006       };
29007     } catch (...) {
29008       {
29009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29010       };
29011     }
29012   }
29013
29014   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29015   return jresult;
29016 }
29017
29018
29019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29020   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29021   Dali::Viewport arg2 ;
29022   Dali::Viewport *argp2 ;
29023
29024   arg1 = (Dali::RenderTask *)jarg1;
29025   argp2 = (Dali::Viewport *)jarg2;
29026   if (!argp2) {
29027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29028     return ;
29029   }
29030   arg2 = *argp2;
29031   {
29032     try {
29033       (arg1)->SetViewport(arg2);
29034     } catch (std::out_of_range& e) {
29035       {
29036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29037       };
29038     } catch (std::exception& e) {
29039       {
29040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29041       };
29042     } catch (Dali::DaliException e) {
29043       {
29044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29045       };
29046     } catch (...) {
29047       {
29048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29049       };
29050     }
29051   }
29052
29053 }
29054
29055
29056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29057   void * jresult ;
29058   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29059   Dali::Viewport result;
29060
29061   arg1 = (Dali::RenderTask *)jarg1;
29062   {
29063     try {
29064       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29065     } catch (std::out_of_range& e) {
29066       {
29067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29068       };
29069     } catch (std::exception& e) {
29070       {
29071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29072       };
29073     } catch (Dali::DaliException e) {
29074       {
29075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29076       };
29077     } catch (...) {
29078       {
29079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29080       };
29081     }
29082   }
29083
29084   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29085   return jresult;
29086 }
29087
29088
29089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29090   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29091   Dali::Vector4 *arg2 = 0 ;
29092
29093   arg1 = (Dali::RenderTask *)jarg1;
29094   arg2 = (Dali::Vector4 *)jarg2;
29095   if (!arg2) {
29096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29097     return ;
29098   }
29099   {
29100     try {
29101       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29102     } catch (std::out_of_range& e) {
29103       {
29104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29105       };
29106     } catch (std::exception& e) {
29107       {
29108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29109       };
29110     } catch (Dali::DaliException e) {
29111       {
29112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29113       };
29114     } catch (...) {
29115       {
29116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29117       };
29118     }
29119   }
29120
29121 }
29122
29123
29124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29125   void * jresult ;
29126   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29127   Dali::Vector4 result;
29128
29129   arg1 = (Dali::RenderTask *)jarg1;
29130   {
29131     try {
29132       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29133     } catch (std::out_of_range& e) {
29134       {
29135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29136       };
29137     } catch (std::exception& e) {
29138       {
29139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29140       };
29141     } catch (Dali::DaliException e) {
29142       {
29143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29144       };
29145     } catch (...) {
29146       {
29147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29148       };
29149     }
29150   }
29151
29152   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29153   return jresult;
29154 }
29155
29156
29157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29158   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29159   bool arg2 ;
29160
29161   arg1 = (Dali::RenderTask *)jarg1;
29162   arg2 = jarg2 ? true : false;
29163   {
29164     try {
29165       (arg1)->SetClearEnabled(arg2);
29166     } catch (std::out_of_range& e) {
29167       {
29168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29169       };
29170     } catch (std::exception& e) {
29171       {
29172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29173       };
29174     } catch (Dali::DaliException e) {
29175       {
29176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29177       };
29178     } catch (...) {
29179       {
29180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29181       };
29182     }
29183   }
29184
29185 }
29186
29187
29188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29189   unsigned int jresult ;
29190   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29191   bool result;
29192
29193   arg1 = (Dali::RenderTask *)jarg1;
29194   {
29195     try {
29196       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29197     } catch (std::out_of_range& e) {
29198       {
29199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29200       };
29201     } catch (std::exception& e) {
29202       {
29203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29204       };
29205     } catch (Dali::DaliException e) {
29206       {
29207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29208       };
29209     } catch (...) {
29210       {
29211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29212       };
29213     }
29214   }
29215
29216   jresult = result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29222   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29223   bool arg2 ;
29224
29225   arg1 = (Dali::RenderTask *)jarg1;
29226   arg2 = jarg2 ? true : false;
29227   {
29228     try {
29229       (arg1)->SetCullMode(arg2);
29230     } catch (std::out_of_range& e) {
29231       {
29232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29233       };
29234     } catch (std::exception& e) {
29235       {
29236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29237       };
29238     } catch (Dali::DaliException e) {
29239       {
29240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29241       };
29242     } catch (...) {
29243       {
29244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29245       };
29246     }
29247   }
29248
29249 }
29250
29251
29252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29253   unsigned int jresult ;
29254   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29255   bool result;
29256
29257   arg1 = (Dali::RenderTask *)jarg1;
29258   {
29259     try {
29260       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29261     } catch (std::out_of_range& e) {
29262       {
29263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29264       };
29265     } catch (std::exception& e) {
29266       {
29267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29268       };
29269     } catch (Dali::DaliException e) {
29270       {
29271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29272       };
29273     } catch (...) {
29274       {
29275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29276       };
29277     }
29278   }
29279
29280   jresult = result;
29281   return jresult;
29282 }
29283
29284
29285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29286   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29287   unsigned int arg2 ;
29288
29289   arg1 = (Dali::RenderTask *)jarg1;
29290   arg2 = (unsigned int)jarg2;
29291   {
29292     try {
29293       (arg1)->SetRefreshRate(arg2);
29294     } catch (std::out_of_range& e) {
29295       {
29296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29297       };
29298     } catch (std::exception& e) {
29299       {
29300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29301       };
29302     } catch (Dali::DaliException e) {
29303       {
29304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29305       };
29306     } catch (...) {
29307       {
29308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29309       };
29310     }
29311   }
29312
29313 }
29314
29315
29316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29317   unsigned int jresult ;
29318   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29319   unsigned int result;
29320
29321   arg1 = (Dali::RenderTask *)jarg1;
29322   {
29323     try {
29324       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29325     } catch (std::out_of_range& e) {
29326       {
29327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29328       };
29329     } catch (std::exception& e) {
29330       {
29331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29332       };
29333     } catch (Dali::DaliException e) {
29334       {
29335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29336       };
29337     } catch (...) {
29338       {
29339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29340       };
29341     }
29342   }
29343
29344   jresult = result;
29345   return jresult;
29346 }
29347
29348
29349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29350   unsigned int jresult ;
29351   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29352   Dali::Vector3 *arg2 = 0 ;
29353   float *arg3 = 0 ;
29354   float *arg4 = 0 ;
29355   bool result;
29356
29357   arg1 = (Dali::RenderTask *)jarg1;
29358   arg2 = (Dali::Vector3 *)jarg2;
29359   if (!arg2) {
29360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29361     return 0;
29362   }
29363   arg3 = (float *)jarg3;
29364   arg4 = (float *)jarg4;
29365   {
29366     try {
29367       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29368     } catch (std::out_of_range& e) {
29369       {
29370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29371       };
29372     } catch (std::exception& e) {
29373       {
29374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29375       };
29376     } catch (Dali::DaliException e) {
29377       {
29378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29379       };
29380     } catch (...) {
29381       {
29382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29383       };
29384     }
29385   }
29386
29387   jresult = result;
29388   return jresult;
29389 }
29390
29391
29392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29393   unsigned int jresult ;
29394   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29395   Dali::Actor arg2 ;
29396   float arg3 ;
29397   float arg4 ;
29398   float *arg5 = 0 ;
29399   float *arg6 = 0 ;
29400   Dali::Actor *argp2 ;
29401   bool result;
29402
29403   arg1 = (Dali::RenderTask *)jarg1;
29404   argp2 = (Dali::Actor *)jarg2;
29405   if (!argp2) {
29406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29407     return 0;
29408   }
29409   arg2 = *argp2;
29410   arg3 = (float)jarg3;
29411   arg4 = (float)jarg4;
29412   arg5 = (float *)jarg5;
29413   arg6 = (float *)jarg6;
29414   {
29415     try {
29416       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29417     } catch (std::out_of_range& e) {
29418       {
29419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29420       };
29421     } catch (std::exception& e) {
29422       {
29423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29424       };
29425     } catch (Dali::DaliException e) {
29426       {
29427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29428       };
29429     } catch (...) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29432       };
29433     }
29434   }
29435
29436   jresult = result;
29437   return jresult;
29438 }
29439
29440
29441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29442   void * jresult ;
29443   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29444   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29445
29446   arg1 = (Dali::RenderTask *)jarg1;
29447   {
29448     try {
29449       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29450     } catch (std::out_of_range& e) {
29451       {
29452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29453       };
29454     } catch (std::exception& e) {
29455       {
29456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29457       };
29458     } catch (Dali::DaliException e) {
29459       {
29460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29461       };
29462     } catch (...) {
29463       {
29464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29465       };
29466     }
29467   }
29468
29469   jresult = (void *)result;
29470   return jresult;
29471 }
29472
29473
29474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29475   void * jresult ;
29476   int arg1 ;
29477   Dali::TouchPoint::State arg2 ;
29478   float arg3 ;
29479   float arg4 ;
29480   Dali::TouchPoint *result = 0 ;
29481
29482   arg1 = (int)jarg1;
29483   arg2 = (Dali::TouchPoint::State)jarg2;
29484   arg3 = (float)jarg3;
29485   arg4 = (float)jarg4;
29486   {
29487     try {
29488       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29489     } catch (std::out_of_range& e) {
29490       {
29491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29492       };
29493     } catch (std::exception& e) {
29494       {
29495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29496       };
29497     } catch (Dali::DaliException e) {
29498       {
29499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29500       };
29501     } catch (...) {
29502       {
29503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29504       };
29505     }
29506   }
29507
29508   jresult = (void *)result;
29509   return jresult;
29510 }
29511
29512
29513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29514   void * jresult ;
29515   int arg1 ;
29516   Dali::TouchPoint::State arg2 ;
29517   float arg3 ;
29518   float arg4 ;
29519   float arg5 ;
29520   float arg6 ;
29521   Dali::TouchPoint *result = 0 ;
29522
29523   arg1 = (int)jarg1;
29524   arg2 = (Dali::TouchPoint::State)jarg2;
29525   arg3 = (float)jarg3;
29526   arg4 = (float)jarg4;
29527   arg5 = (float)jarg5;
29528   arg6 = (float)jarg6;
29529   {
29530     try {
29531       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29532     } catch (std::out_of_range& e) {
29533       {
29534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (std::exception& e) {
29537       {
29538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29539       };
29540     } catch (Dali::DaliException e) {
29541       {
29542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29543       };
29544     } catch (...) {
29545       {
29546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29547       };
29548     }
29549   }
29550
29551   jresult = (void *)result;
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29557   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29558
29559   arg1 = (Dali::TouchPoint *)jarg1;
29560   {
29561     try {
29562       delete arg1;
29563     } catch (std::out_of_range& e) {
29564       {
29565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29566       };
29567     } catch (std::exception& e) {
29568       {
29569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29570       };
29571     } catch (Dali::DaliException e) {
29572       {
29573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29574       };
29575     } catch (...) {
29576       {
29577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29578       };
29579     }
29580   }
29581
29582 }
29583
29584
29585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29586   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29587   int arg2 ;
29588
29589   arg1 = (Dali::TouchPoint *)jarg1;
29590   arg2 = (int)jarg2;
29591   if (arg1) (arg1)->deviceId = arg2;
29592 }
29593
29594
29595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29596   int jresult ;
29597   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29598   int result;
29599
29600   arg1 = (Dali::TouchPoint *)jarg1;
29601   result = (int) ((arg1)->deviceId);
29602   jresult = result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29608   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29609   Dali::TouchPoint::State arg2 ;
29610
29611   arg1 = (Dali::TouchPoint *)jarg1;
29612   arg2 = (Dali::TouchPoint::State)jarg2;
29613   if (arg1) (arg1)->state = arg2;
29614 }
29615
29616
29617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29618   int jresult ;
29619   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29620   Dali::TouchPoint::State result;
29621
29622   arg1 = (Dali::TouchPoint *)jarg1;
29623   result = (Dali::TouchPoint::State) ((arg1)->state);
29624   jresult = (int)result;
29625   return jresult;
29626 }
29627
29628
29629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29630   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29631   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29632
29633   arg1 = (Dali::TouchPoint *)jarg1;
29634   arg2 = (Dali::Actor *)jarg2;
29635   if (arg1) (arg1)->hitActor = *arg2;
29636 }
29637
29638
29639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29640   void * jresult ;
29641   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29642   Dali::Actor *result = 0 ;
29643
29644   arg1 = (Dali::TouchPoint *)jarg1;
29645   result = (Dali::Actor *)& ((arg1)->hitActor);
29646   jresult = (void *)result;
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29652   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29653   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29654
29655   arg1 = (Dali::TouchPoint *)jarg1;
29656   arg2 = (Dali::Vector2 *)jarg2;
29657   if (arg1) (arg1)->local = *arg2;
29658 }
29659
29660
29661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29662   void * jresult ;
29663   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29664   Dali::Vector2 *result = 0 ;
29665
29666   arg1 = (Dali::TouchPoint *)jarg1;
29667   result = (Dali::Vector2 *)& ((arg1)->local);
29668   jresult = (void *)result;
29669   return jresult;
29670 }
29671
29672
29673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29674   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29675   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29676
29677   arg1 = (Dali::TouchPoint *)jarg1;
29678   arg2 = (Dali::Vector2 *)jarg2;
29679   if (arg1) (arg1)->screen = *arg2;
29680 }
29681
29682
29683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29684   void * jresult ;
29685   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29686   Dali::Vector2 *result = 0 ;
29687
29688   arg1 = (Dali::TouchPoint *)jarg1;
29689   result = (Dali::Vector2 *)& ((arg1)->screen);
29690   jresult = (void *)result;
29691   return jresult;
29692 }
29693
29694
29695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29696   void * jresult ;
29697   Dali::TouchData *result = 0 ;
29698
29699   {
29700     try {
29701       result = (Dali::TouchData *)new Dali::TouchData();
29702     } catch (std::out_of_range& e) {
29703       {
29704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29705       };
29706     } catch (std::exception& e) {
29707       {
29708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29709       };
29710     } catch (Dali::DaliException e) {
29711       {
29712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29713       };
29714     } catch (...) {
29715       {
29716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29717       };
29718     }
29719   }
29720
29721   jresult = (void *)result;
29722   return jresult;
29723 }
29724
29725
29726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29727   void * jresult ;
29728   Dali::TouchData *arg1 = 0 ;
29729   Dali::TouchData *result = 0 ;
29730
29731   arg1 = (Dali::TouchData *)jarg1;
29732   if (!arg1) {
29733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29734     return 0;
29735   }
29736   {
29737     try {
29738       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29739     } catch (std::out_of_range& e) {
29740       {
29741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29742       };
29743     } catch (std::exception& e) {
29744       {
29745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29746       };
29747     } catch (Dali::DaliException e) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29750       };
29751     } catch (...) {
29752       {
29753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29754       };
29755     }
29756   }
29757
29758   jresult = (void *)result;
29759   return jresult;
29760 }
29761
29762
29763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29764   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29765
29766   arg1 = (Dali::TouchData *)jarg1;
29767   {
29768     try {
29769       delete arg1;
29770     } catch (std::out_of_range& e) {
29771       {
29772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29773       };
29774     } catch (std::exception& e) {
29775       {
29776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29777       };
29778     } catch (Dali::DaliException e) {
29779       {
29780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29781       };
29782     } catch (...) {
29783       {
29784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29785       };
29786     }
29787   }
29788
29789 }
29790
29791
29792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29793   void * jresult ;
29794   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29795   Dali::TouchData *arg2 = 0 ;
29796   Dali::TouchData *result = 0 ;
29797
29798   arg1 = (Dali::TouchData *)jarg1;
29799   arg2 = (Dali::TouchData *)jarg2;
29800   if (!arg2) {
29801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29802     return 0;
29803   }
29804   {
29805     try {
29806       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29807     } catch (std::out_of_range& e) {
29808       {
29809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29810       };
29811     } catch (std::exception& e) {
29812       {
29813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29814       };
29815     } catch (Dali::DaliException e) {
29816       {
29817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29818       };
29819     } catch (...) {
29820       {
29821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29822       };
29823     }
29824   }
29825
29826   jresult = (void *)result;
29827   return jresult;
29828 }
29829
29830
29831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29832   unsigned long jresult ;
29833   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29834   unsigned long result;
29835
29836   arg1 = (Dali::TouchData *)jarg1;
29837   {
29838     try {
29839       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29840     } catch (std::out_of_range& e) {
29841       {
29842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29843       };
29844     } catch (std::exception& e) {
29845       {
29846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29847       };
29848     } catch (Dali::DaliException e) {
29849       {
29850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29851       };
29852     } catch (...) {
29853       {
29854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29855       };
29856     }
29857   }
29858
29859   jresult = (unsigned long)result;
29860   return jresult;
29861 }
29862
29863
29864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29865   unsigned long jresult ;
29866   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29867   std::size_t result;
29868
29869   arg1 = (Dali::TouchData *)jarg1;
29870   {
29871     try {
29872       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29873     } catch (std::out_of_range& e) {
29874       {
29875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29876       };
29877     } catch (std::exception& e) {
29878       {
29879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29880       };
29881     } catch (Dali::DaliException e) {
29882       {
29883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29884       };
29885     } catch (...) {
29886       {
29887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29888       };
29889     }
29890   }
29891
29892   jresult = (unsigned long)result;
29893   return jresult;
29894 }
29895
29896
29897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29898   int jresult ;
29899   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29900   std::size_t arg2 ;
29901   int32_t result;
29902
29903   arg1 = (Dali::TouchData *)jarg1;
29904   arg2 = (std::size_t)jarg2;
29905   {
29906     try {
29907       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29908     } catch (std::out_of_range& e) {
29909       {
29910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29911       };
29912     } catch (std::exception& e) {
29913       {
29914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29915       };
29916     } catch (Dali::DaliException e) {
29917       {
29918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29919       };
29920     } catch (...) {
29921       {
29922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29923       };
29924     }
29925   }
29926
29927   jresult = result;
29928   return jresult;
29929 }
29930
29931
29932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29933   int jresult ;
29934   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29935   std::size_t arg2 ;
29936   Dali::PointState::Type result;
29937
29938   arg1 = (Dali::TouchData *)jarg1;
29939   arg2 = (std::size_t)jarg2;
29940   {
29941     try {
29942       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29943     } catch (std::out_of_range& e) {
29944       {
29945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29946       };
29947     } catch (std::exception& e) {
29948       {
29949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29950       };
29951     } catch (Dali::DaliException e) {
29952       {
29953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29954       };
29955     } catch (...) {
29956       {
29957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29958       };
29959     }
29960   }
29961
29962   jresult = (int)result;
29963   return jresult;
29964 }
29965
29966
29967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29968   void * jresult ;
29969   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29970   std::size_t arg2 ;
29971   Dali::Actor result;
29972
29973   arg1 = (Dali::TouchData *)jarg1;
29974   arg2 = (std::size_t)jarg2;
29975   {
29976     try {
29977       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29978     } catch (std::out_of_range& e) {
29979       {
29980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29981       };
29982     } catch (std::exception& e) {
29983       {
29984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29985       };
29986     } catch (Dali::DaliException e) {
29987       {
29988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29989       };
29990     } catch (...) {
29991       {
29992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29993       };
29994     }
29995   }
29996
29997   jresult = new Dali::Actor((const Dali::Actor &)result);
29998   return jresult;
29999 }
30000
30001
30002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30003   void * jresult ;
30004   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30005   std::size_t arg2 ;
30006   Dali::Vector2 *result = 0 ;
30007
30008   arg1 = (Dali::TouchData *)jarg1;
30009   arg2 = (std::size_t)jarg2;
30010   {
30011     try {
30012       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30013     } catch (std::out_of_range& e) {
30014       {
30015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30016       };
30017     } catch (std::exception& e) {
30018       {
30019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30020       };
30021     } catch (Dali::DaliException e) {
30022       {
30023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30024       };
30025     } catch (...) {
30026       {
30027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30028       };
30029     }
30030   }
30031
30032   jresult = (void *)result;
30033   return jresult;
30034 }
30035
30036
30037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30038   void * jresult ;
30039   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30040   std::size_t arg2 ;
30041   Dali::Vector2 *result = 0 ;
30042
30043   arg1 = (Dali::TouchData *)jarg1;
30044   arg2 = (std::size_t)jarg2;
30045   {
30046     try {
30047       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30048     } catch (std::out_of_range& e) {
30049       {
30050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30051       };
30052     } catch (std::exception& e) {
30053       {
30054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30055       };
30056     } catch (Dali::DaliException e) {
30057       {
30058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30059       };
30060     } catch (...) {
30061       {
30062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30063       };
30064     }
30065   }
30066
30067   jresult = (void *)result;
30068   return jresult;
30069 }
30070
30071
30072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30073   float jresult ;
30074   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30075   std::size_t arg2 ;
30076   float result;
30077
30078   arg1 = (Dali::TouchData *)jarg1;
30079   arg2 = (std::size_t)jarg2;
30080   {
30081     try {
30082       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30083     } catch (std::out_of_range& e) {
30084       {
30085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30086       };
30087     } catch (std::exception& e) {
30088       {
30089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30090       };
30091     } catch (Dali::DaliException e) {
30092       {
30093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30094       };
30095     } catch (...) {
30096       {
30097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30098       };
30099     }
30100   }
30101
30102   jresult = result;
30103   return jresult;
30104 }
30105
30106
30107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30108   void * jresult ;
30109   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30110   std::size_t arg2 ;
30111   Dali::Vector2 *result = 0 ;
30112
30113   arg1 = (Dali::TouchData *)jarg1;
30114   arg2 = (std::size_t)jarg2;
30115   {
30116     try {
30117       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30118     } catch (std::out_of_range& e) {
30119       {
30120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30121       };
30122     } catch (std::exception& e) {
30123       {
30124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30125       };
30126     } catch (Dali::DaliException e) {
30127       {
30128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30129       };
30130     } catch (...) {
30131       {
30132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30133       };
30134     }
30135   }
30136
30137   jresult = (void *)result;
30138   return jresult;
30139 }
30140
30141
30142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30143   float jresult ;
30144   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30145   std::size_t arg2 ;
30146   float result;
30147
30148   arg1 = (Dali::TouchData *)jarg1;
30149   arg2 = (std::size_t)jarg2;
30150   {
30151     try {
30152       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30153     } catch (std::out_of_range& e) {
30154       {
30155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30156       };
30157     } catch (std::exception& e) {
30158       {
30159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30160       };
30161     } catch (Dali::DaliException e) {
30162       {
30163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30164       };
30165     } catch (...) {
30166       {
30167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30168       };
30169     }
30170   }
30171
30172   jresult = result;
30173   return jresult;
30174 }
30175
30176
30177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30178   void * jresult ;
30179   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30180   std::size_t arg2 ;
30181   Dali::Degree result;
30182
30183   arg1 = (Dali::TouchData *)jarg1;
30184   arg2 = (std::size_t)jarg2;
30185   {
30186     try {
30187       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30188     } catch (std::out_of_range& e) {
30189       {
30190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30191       };
30192     } catch (std::exception& e) {
30193       {
30194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30195       };
30196     } catch (Dali::DaliException e) {
30197       {
30198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30199       };
30200     } catch (...) {
30201       {
30202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30203       };
30204     }
30205   }
30206
30207   jresult = new Dali::Degree((const Dali::Degree &)result);
30208   return jresult;
30209 }
30210
30211
30212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30213   int jresult ;
30214   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30215   std::size_t arg2 ;
30216   Dali::MouseButton::Type result;
30217
30218   arg1 = (Dali::TouchData *)jarg1;
30219   arg2 = (std::size_t)jarg2;
30220   {
30221     try {
30222       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30223     } catch (std::out_of_range& e) {
30224       {
30225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30226       };
30227     } catch (std::exception& e) {
30228       {
30229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30230       };
30231     } catch (Dali::DaliException e) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30234       };
30235     } catch (...) {
30236       {
30237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30238       };
30239     }
30240   }
30241
30242   jresult = static_cast< int >(result);
30243   return jresult;
30244 }
30245
30246
30247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30248   void * jresult ;
30249   Dali::GestureDetector *result = 0 ;
30250
30251   {
30252     try {
30253       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30254     } catch (std::out_of_range& e) {
30255       {
30256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30257       };
30258     } catch (std::exception& e) {
30259       {
30260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30261       };
30262     } catch (Dali::DaliException e) {
30263       {
30264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30265       };
30266     } catch (...) {
30267       {
30268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30269       };
30270     }
30271   }
30272
30273   jresult = (void *)result;
30274   return jresult;
30275 }
30276
30277
30278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30279   void * jresult ;
30280   Dali::BaseHandle arg1 ;
30281   Dali::BaseHandle *argp1 ;
30282   Dali::GestureDetector result;
30283
30284   argp1 = (Dali::BaseHandle *)jarg1;
30285   if (!argp1) {
30286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30287     return 0;
30288   }
30289   arg1 = *argp1;
30290   {
30291     try {
30292       result = Dali::GestureDetector::DownCast(arg1);
30293     } catch (std::out_of_range& e) {
30294       {
30295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (std::exception& e) {
30298       {
30299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (Dali::DaliException e) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30304       };
30305     } catch (...) {
30306       {
30307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30308       };
30309     }
30310   }
30311
30312   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30313   return jresult;
30314 }
30315
30316
30317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30318   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30319
30320   arg1 = (Dali::GestureDetector *)jarg1;
30321   {
30322     try {
30323       delete arg1;
30324     } catch (std::out_of_range& e) {
30325       {
30326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (std::exception& e) {
30329       {
30330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30331       };
30332     } catch (Dali::DaliException e) {
30333       {
30334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30335       };
30336     } catch (...) {
30337       {
30338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30339       };
30340     }
30341   }
30342
30343 }
30344
30345
30346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30347   void * jresult ;
30348   Dali::GestureDetector *arg1 = 0 ;
30349   Dali::GestureDetector *result = 0 ;
30350
30351   arg1 = (Dali::GestureDetector *)jarg1;
30352   if (!arg1) {
30353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30354     return 0;
30355   }
30356   {
30357     try {
30358       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30359     } catch (std::out_of_range& e) {
30360       {
30361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30362       };
30363     } catch (std::exception& e) {
30364       {
30365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30366       };
30367     } catch (Dali::DaliException e) {
30368       {
30369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30370       };
30371     } catch (...) {
30372       {
30373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30374       };
30375     }
30376   }
30377
30378   jresult = (void *)result;
30379   return jresult;
30380 }
30381
30382
30383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30384   void * jresult ;
30385   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30386   Dali::GestureDetector *arg2 = 0 ;
30387   Dali::GestureDetector *result = 0 ;
30388
30389   arg1 = (Dali::GestureDetector *)jarg1;
30390   arg2 = (Dali::GestureDetector *)jarg2;
30391   if (!arg2) {
30392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30393     return 0;
30394   }
30395   {
30396     try {
30397       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30398     } catch (std::out_of_range& e) {
30399       {
30400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30401       };
30402     } catch (std::exception& e) {
30403       {
30404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30405       };
30406     } catch (Dali::DaliException e) {
30407       {
30408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30409       };
30410     } catch (...) {
30411       {
30412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30413       };
30414     }
30415   }
30416
30417   jresult = (void *)result;
30418   return jresult;
30419 }
30420
30421
30422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30423   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30424   Dali::Actor arg2 ;
30425   Dali::Actor *argp2 ;
30426
30427   arg1 = (Dali::GestureDetector *)jarg1;
30428   argp2 = (Dali::Actor *)jarg2;
30429   if (!argp2) {
30430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30431     return ;
30432   }
30433   arg2 = *argp2;
30434   {
30435     try {
30436       (arg1)->Attach(arg2);
30437     } catch (std::out_of_range& e) {
30438       {
30439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30440       };
30441     } catch (std::exception& e) {
30442       {
30443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30444       };
30445     } catch (Dali::DaliException e) {
30446       {
30447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30448       };
30449     } catch (...) {
30450       {
30451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30452       };
30453     }
30454   }
30455
30456 }
30457
30458
30459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30460   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30461   Dali::Actor arg2 ;
30462   Dali::Actor *argp2 ;
30463
30464   arg1 = (Dali::GestureDetector *)jarg1;
30465   argp2 = (Dali::Actor *)jarg2;
30466   if (!argp2) {
30467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30468     return ;
30469   }
30470   arg2 = *argp2;
30471   {
30472     try {
30473       (arg1)->Detach(arg2);
30474     } catch (std::out_of_range& e) {
30475       {
30476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30477       };
30478     } catch (std::exception& e) {
30479       {
30480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30481       };
30482     } catch (Dali::DaliException e) {
30483       {
30484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30485       };
30486     } catch (...) {
30487       {
30488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30489       };
30490     }
30491   }
30492
30493 }
30494
30495
30496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30497   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30498
30499   arg1 = (Dali::GestureDetector *)jarg1;
30500   {
30501     try {
30502       (arg1)->DetachAll();
30503     } catch (std::out_of_range& e) {
30504       {
30505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30506       };
30507     } catch (std::exception& e) {
30508       {
30509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30510       };
30511     } catch (Dali::DaliException e) {
30512       {
30513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30514       };
30515     } catch (...) {
30516       {
30517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30518       };
30519     }
30520   }
30521
30522 }
30523
30524
30525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30526   unsigned long jresult ;
30527   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30528   size_t result;
30529
30530   arg1 = (Dali::GestureDetector *)jarg1;
30531   {
30532     try {
30533       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30534     } catch (std::out_of_range& e) {
30535       {
30536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (std::exception& e) {
30539       {
30540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30541       };
30542     } catch (Dali::DaliException e) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30545       };
30546     } catch (...) {
30547       {
30548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30549       };
30550     }
30551   }
30552
30553   jresult = (unsigned long)result;
30554   return jresult;
30555 }
30556
30557
30558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30559   void * jresult ;
30560   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30561   size_t arg2 ;
30562   Dali::Actor result;
30563
30564   arg1 = (Dali::GestureDetector *)jarg1;
30565   arg2 = (size_t)jarg2;
30566   {
30567     try {
30568       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30569     } catch (std::out_of_range& e) {
30570       {
30571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30572       };
30573     } catch (std::exception& e) {
30574       {
30575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30576       };
30577     } catch (Dali::DaliException e) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30584       };
30585     }
30586   }
30587
30588   jresult = new Dali::Actor((const Dali::Actor &)result);
30589   return jresult;
30590 }
30591
30592
30593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30594   void * jresult ;
30595   Dali::Gesture *arg1 = 0 ;
30596   Dali::Gesture *result = 0 ;
30597
30598   arg1 = (Dali::Gesture *)jarg1;
30599   if (!arg1) {
30600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30601     return 0;
30602   }
30603   {
30604     try {
30605       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30606     } catch (std::out_of_range& e) {
30607       {
30608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30609       };
30610     } catch (std::exception& e) {
30611       {
30612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30613       };
30614     } catch (Dali::DaliException e) {
30615       {
30616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30617       };
30618     } catch (...) {
30619       {
30620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30621       };
30622     }
30623   }
30624
30625   jresult = (void *)result;
30626   return jresult;
30627 }
30628
30629
30630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30631   void * jresult ;
30632   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30633   Dali::Gesture *arg2 = 0 ;
30634   Dali::Gesture *result = 0 ;
30635
30636   arg1 = (Dali::Gesture *)jarg1;
30637   arg2 = (Dali::Gesture *)jarg2;
30638   if (!arg2) {
30639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30640     return 0;
30641   }
30642   {
30643     try {
30644       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30645     } catch (std::out_of_range& e) {
30646       {
30647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30648       };
30649     } catch (std::exception& e) {
30650       {
30651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30652       };
30653     } catch (Dali::DaliException e) {
30654       {
30655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30656       };
30657     } catch (...) {
30658       {
30659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30660       };
30661     }
30662   }
30663
30664   jresult = (void *)result;
30665   return jresult;
30666 }
30667
30668
30669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30670   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30671
30672   arg1 = (Dali::Gesture *)jarg1;
30673   {
30674     try {
30675       delete arg1;
30676     } catch (std::out_of_range& e) {
30677       {
30678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30679       };
30680     } catch (std::exception& e) {
30681       {
30682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30683       };
30684     } catch (Dali::DaliException e) {
30685       {
30686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30687       };
30688     } catch (...) {
30689       {
30690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30691       };
30692     }
30693   }
30694
30695 }
30696
30697
30698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30699   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30700   Dali::Gesture::Type arg2 ;
30701
30702   arg1 = (Dali::Gesture *)jarg1;
30703   arg2 = (Dali::Gesture::Type)jarg2;
30704   if (arg1) (arg1)->type = arg2;
30705 }
30706
30707
30708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30709   int jresult ;
30710   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30711   Dali::Gesture::Type result;
30712
30713   arg1 = (Dali::Gesture *)jarg1;
30714   result = (Dali::Gesture::Type) ((arg1)->type);
30715   jresult = (int)result;
30716   return jresult;
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30721   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30722   Dali::Gesture::State arg2 ;
30723
30724   arg1 = (Dali::Gesture *)jarg1;
30725   arg2 = (Dali::Gesture::State)jarg2;
30726   if (arg1) (arg1)->state = arg2;
30727 }
30728
30729
30730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30731   int jresult ;
30732   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30733   Dali::Gesture::State result;
30734
30735   arg1 = (Dali::Gesture *)jarg1;
30736   result = (Dali::Gesture::State) ((arg1)->state);
30737   jresult = (int)result;
30738   return jresult;
30739 }
30740
30741
30742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30743   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30744   unsigned int arg2 ;
30745
30746   arg1 = (Dali::Gesture *)jarg1;
30747   arg2 = (unsigned int)jarg2;
30748   if (arg1) (arg1)->time = arg2;
30749 }
30750
30751
30752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30753   unsigned int jresult ;
30754   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30755   unsigned int result;
30756
30757   arg1 = (Dali::Gesture *)jarg1;
30758   result = (unsigned int) ((arg1)->time);
30759   jresult = result;
30760   return jresult;
30761 }
30762
30763
30764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30765   void * jresult ;
30766   Dali::HoverEvent *result = 0 ;
30767
30768   {
30769     try {
30770       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30771     } catch (std::out_of_range& e) {
30772       {
30773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30774       };
30775     } catch (std::exception& e) {
30776       {
30777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30778       };
30779     } catch (Dali::DaliException e) {
30780       {
30781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30782       };
30783     } catch (...) {
30784       {
30785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30786       };
30787     }
30788   }
30789
30790   jresult = (void *)result;
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30796   void * jresult ;
30797   unsigned long arg1 ;
30798   Dali::HoverEvent *result = 0 ;
30799
30800   arg1 = (unsigned long)jarg1;
30801   {
30802     try {
30803       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30804     } catch (std::out_of_range& e) {
30805       {
30806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (std::exception& e) {
30809       {
30810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30811       };
30812     } catch (Dali::DaliException e) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30815       };
30816     } catch (...) {
30817       {
30818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30819       };
30820     }
30821   }
30822
30823   jresult = (void *)result;
30824   return jresult;
30825 }
30826
30827
30828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30829   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30830
30831   arg1 = (Dali::HoverEvent *)jarg1;
30832   {
30833     try {
30834       delete arg1;
30835     } catch (std::out_of_range& e) {
30836       {
30837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30838       };
30839     } catch (std::exception& e) {
30840       {
30841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30842       };
30843     } catch (Dali::DaliException e) {
30844       {
30845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30846       };
30847     } catch (...) {
30848       {
30849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30850       };
30851     }
30852   }
30853
30854 }
30855
30856
30857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30858   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30859   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30860
30861   arg1 = (Dali::HoverEvent *)jarg1;
30862   arg2 = (Dali::TouchPointContainer *)jarg2;
30863   if (arg1) (arg1)->points = *arg2;
30864 }
30865
30866
30867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30868   void * jresult ;
30869   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30870   Dali::TouchPointContainer *result = 0 ;
30871
30872   arg1 = (Dali::HoverEvent *)jarg1;
30873   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30874   jresult = (void *)result;
30875   return jresult;
30876 }
30877
30878
30879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30880   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30881   unsigned long arg2 ;
30882
30883   arg1 = (Dali::HoverEvent *)jarg1;
30884   arg2 = (unsigned long)jarg2;
30885   if (arg1) (arg1)->time = arg2;
30886 }
30887
30888
30889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30890   unsigned long jresult ;
30891   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30892   unsigned long result;
30893
30894   arg1 = (Dali::HoverEvent *)jarg1;
30895   result = (unsigned long) ((arg1)->time);
30896   jresult = (unsigned long)result;
30897   return jresult;
30898 }
30899
30900
30901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30902   unsigned int jresult ;
30903   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30904   unsigned int result;
30905
30906   arg1 = (Dali::HoverEvent *)jarg1;
30907   {
30908     try {
30909       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30910     } catch (std::out_of_range& e) {
30911       {
30912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30913       };
30914     } catch (std::exception& e) {
30915       {
30916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30917       };
30918     } catch (Dali::DaliException e) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30921       };
30922     } catch (...) {
30923       {
30924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30925       };
30926     }
30927   }
30928
30929   jresult = result;
30930   return jresult;
30931 }
30932
30933
30934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30935   void * jresult ;
30936   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30937   unsigned int arg2 ;
30938   Dali::TouchPoint *result = 0 ;
30939
30940   arg1 = (Dali::HoverEvent *)jarg1;
30941   arg2 = (unsigned int)jarg2;
30942   {
30943     try {
30944       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30945     } catch (std::out_of_range& e) {
30946       {
30947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (std::exception& e) {
30950       {
30951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30952       };
30953     } catch (Dali::DaliException e) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30956       };
30957     } catch (...) {
30958       {
30959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30960       };
30961     }
30962   }
30963
30964   jresult = (void *)result;
30965   return jresult;
30966 }
30967
30968
30969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30970   void * jresult ;
30971   Dali::KeyEvent *result = 0 ;
30972
30973   {
30974     try {
30975       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30976     } catch (std::out_of_range& e) {
30977       {
30978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30979       };
30980     } catch (std::exception& e) {
30981       {
30982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30983       };
30984     } catch (Dali::DaliException e) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30987       };
30988     } catch (...) {
30989       {
30990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30991       };
30992     }
30993   }
30994
30995   jresult = (void *)result;
30996   return jresult;
30997 }
30998
30999
31000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31001   void * jresult ;
31002   std::string *arg1 = 0 ;
31003   std::string *arg2 = 0 ;
31004   int arg3 ;
31005   int arg4 ;
31006   unsigned long arg5 ;
31007   Dali::KeyEvent::State *arg6 = 0 ;
31008   Dali::KeyEvent::State temp6 ;
31009   Dali::KeyEvent *result = 0 ;
31010
31011   if (!jarg1) {
31012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31013     return 0;
31014   }
31015   std::string arg1_str(jarg1);
31016   arg1 = &arg1_str;
31017   if (!jarg2) {
31018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31019     return 0;
31020   }
31021   std::string arg2_str(jarg2);
31022   arg2 = &arg2_str;
31023   arg3 = (int)jarg3;
31024   arg4 = (int)jarg4;
31025   arg5 = (unsigned long)jarg5;
31026   temp6 = (Dali::KeyEvent::State)jarg6;
31027   arg6 = &temp6;
31028   {
31029     try {
31030       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31031     } catch (std::out_of_range& e) {
31032       {
31033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31034       };
31035     } catch (std::exception& e) {
31036       {
31037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31038       };
31039     } catch (Dali::DaliException e) {
31040       {
31041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31042       };
31043     } catch (...) {
31044       {
31045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31046       };
31047     }
31048   }
31049
31050   jresult = (void *)result;
31051
31052   //argout typemap for const std::string&
31053
31054
31055   //argout typemap for const std::string&
31056
31057   return jresult;
31058 }
31059
31060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31061   void * jresult ;
31062   Dali::KeyEvent *arg1 = 0 ;
31063   Dali::KeyEvent *result = 0 ;
31064
31065   arg1 = (Dali::KeyEvent *)jarg1;
31066   if (!arg1) {
31067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31068     return 0;
31069   }
31070   {
31071     try {
31072       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31073     } catch (std::out_of_range& e) {
31074       {
31075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (std::exception& e) {
31078       {
31079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31080       };
31081     } catch (Dali::DaliException e) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31084       };
31085     } catch (...) {
31086       {
31087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31088       };
31089     }
31090   }
31091
31092   jresult = (void *)result;
31093   return jresult;
31094 }
31095
31096
31097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31098   void * jresult ;
31099   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31100   Dali::KeyEvent *arg2 = 0 ;
31101   Dali::KeyEvent *result = 0 ;
31102
31103   arg1 = (Dali::KeyEvent *)jarg1;
31104   arg2 = (Dali::KeyEvent *)jarg2;
31105   if (!arg2) {
31106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31107     return 0;
31108   }
31109   {
31110     try {
31111       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31112     } catch (std::out_of_range& e) {
31113       {
31114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (std::exception& e) {
31117       {
31118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31119       };
31120     } catch (Dali::DaliException e) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31123       };
31124     } catch (...) {
31125       {
31126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31127       };
31128     }
31129   }
31130
31131   jresult = (void *)result;
31132   return jresult;
31133 }
31134
31135
31136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31137   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31138
31139   arg1 = (Dali::KeyEvent *)jarg1;
31140   {
31141     try {
31142       delete arg1;
31143     } catch (std::out_of_range& e) {
31144       {
31145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (std::exception& e) {
31148       {
31149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31150       };
31151     } catch (Dali::DaliException e) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31154       };
31155     } catch (...) {
31156       {
31157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31158       };
31159     }
31160   }
31161
31162 }
31163
31164
31165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31166   unsigned int jresult ;
31167   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31168   bool result;
31169
31170   arg1 = (Dali::KeyEvent *)jarg1;
31171   {
31172     try {
31173       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31174     } catch (std::out_of_range& e) {
31175       {
31176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31177       };
31178     } catch (std::exception& e) {
31179       {
31180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31181       };
31182     } catch (Dali::DaliException e) {
31183       {
31184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31185       };
31186     } catch (...) {
31187       {
31188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31189       };
31190     }
31191   }
31192
31193   jresult = result;
31194   return jresult;
31195 }
31196
31197
31198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31199   unsigned int jresult ;
31200   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31201   bool result;
31202
31203   arg1 = (Dali::KeyEvent *)jarg1;
31204   {
31205     try {
31206       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31207     } catch (std::out_of_range& e) {
31208       {
31209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (std::exception& e) {
31212       {
31213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31214       };
31215     } catch (Dali::DaliException e) {
31216       {
31217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31218       };
31219     } catch (...) {
31220       {
31221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31222       };
31223     }
31224   }
31225
31226   jresult = result;
31227   return jresult;
31228 }
31229
31230
31231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31232   unsigned int jresult ;
31233   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31234   bool result;
31235
31236   arg1 = (Dali::KeyEvent *)jarg1;
31237   {
31238     try {
31239       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31240     } catch (std::out_of_range& e) {
31241       {
31242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31243       };
31244     } catch (std::exception& e) {
31245       {
31246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31247       };
31248     } catch (Dali::DaliException e) {
31249       {
31250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31251       };
31252     } catch (...) {
31253       {
31254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31255       };
31256     }
31257   }
31258
31259   jresult = result;
31260   return jresult;
31261 }
31262
31263
31264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31265   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31266   std::string *arg2 = 0 ;
31267
31268   arg1 = (Dali::KeyEvent *)jarg1;
31269   if (!jarg2) {
31270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31271     return ;
31272   }
31273   std::string arg2_str(jarg2);
31274   arg2 = &arg2_str;
31275   if (arg1) (arg1)->keyPressedName = *arg2;
31276
31277   //argout typemap for const std::string&
31278
31279 }
31280
31281
31282 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31283   char * jresult ;
31284
31285   if( jarg1 == NULL )
31286   {
31287     jresult = SWIG_csharp_string_callback( "" );
31288   }
31289   else
31290   {
31291     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31292     std::string *result = 0;
31293
31294     arg1 = ( Dali::KeyEvent * )jarg1;
31295     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31296     jresult = SWIG_csharp_string_callback( result->c_str() );
31297   }
31298
31299   return jresult;
31300 }
31301
31302
31303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31304   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31305   std::string *arg2 = 0 ;
31306
31307   arg1 = (Dali::KeyEvent *)jarg1;
31308   if (!jarg2) {
31309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31310     return ;
31311   }
31312   std::string arg2_str(jarg2);
31313   arg2 = &arg2_str;
31314   if (arg1) (arg1)->keyPressed = *arg2;
31315
31316   //argout typemap for const std::string&
31317
31318 }
31319
31320
31321 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31322   char * jresult ;
31323   if( NULL == jarg1 )
31324   {
31325     jresult = SWIG_csharp_string_callback( "" );
31326   }
31327   else
31328   {
31329     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31330     std::string *result = 0;
31331
31332     arg1 = ( Dali::KeyEvent * )jarg1;
31333     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31334     jresult = SWIG_csharp_string_callback( result->c_str() );
31335   }
31336   return jresult;
31337 }
31338
31339
31340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31341   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31342   int arg2 ;
31343
31344   arg1 = (Dali::KeyEvent *)jarg1;
31345   arg2 = (int)jarg2;
31346   if (arg1) (arg1)->keyCode = arg2;
31347 }
31348
31349
31350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31351   int jresult ;
31352   if( NULL == jarg1 )
31353   {
31354     jresult = -1;
31355   }
31356   else
31357   {
31358     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31359     int result;
31360
31361     arg1 = ( Dali::KeyEvent * )jarg1;
31362     result = (int)( ( arg1 )->keyCode );
31363     jresult = result;
31364   }
31365   return jresult;
31366 }
31367
31368
31369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31370   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31371   int arg2 ;
31372
31373   arg1 = (Dali::KeyEvent *)jarg1;
31374   arg2 = (int)jarg2;
31375   if (arg1) (arg1)->keyModifier = arg2;
31376 }
31377
31378
31379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31380   int jresult ;
31381   if( jarg1 == NULL )
31382   {
31383     jresult = -1;
31384   }
31385   else
31386   {
31387     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31388     int result;
31389
31390     arg1 = ( Dali::KeyEvent * )jarg1;
31391     result = (int)( ( arg1 )->keyModifier );
31392     jresult = result;
31393   }
31394   return jresult;
31395 }
31396
31397
31398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31399   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31400   unsigned long arg2 ;
31401
31402   arg1 = (Dali::KeyEvent *)jarg1;
31403   arg2 = (unsigned long)jarg2;
31404   if (arg1) (arg1)->time = arg2;
31405 }
31406
31407
31408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31409   unsigned long jresult ;
31410   if( jarg1 == NULL )
31411   {
31412     jresult = 0;
31413   }
31414   else
31415   {
31416     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31417     unsigned long result;
31418
31419     arg1 = ( Dali::KeyEvent * )jarg1;
31420     result = (unsigned long)( ( arg1 )->time );
31421     jresult = (unsigned long)result;
31422   }
31423   return jresult;
31424 }
31425
31426
31427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31428   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31429   Dali::KeyEvent::State arg2 ;
31430
31431   arg1 = (Dali::KeyEvent *)jarg1;
31432   arg2 = (Dali::KeyEvent::State)jarg2;
31433   if (arg1) (arg1)->state = arg2;
31434 }
31435
31436
31437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31438   int jresult ;
31439   if( jarg1 == NULL )
31440   {
31441     jresult = -1;
31442   }
31443   else
31444   {
31445     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31446     Dali::KeyEvent::State result;
31447
31448     arg1 = ( Dali::KeyEvent * )jarg1;
31449     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31450     jresult = (int)result;
31451   }
31452   return jresult;
31453 }
31454
31455
31456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31457   void * jresult ;
31458   Dali::LongPressGestureDetector *result = 0 ;
31459
31460   {
31461     try {
31462       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31463     } catch (std::out_of_range& e) {
31464       {
31465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (std::exception& e) {
31468       {
31469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (Dali::DaliException e) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31474       };
31475     } catch (...) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31478       };
31479     }
31480   }
31481
31482   jresult = (void *)result;
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31488   void * jresult ;
31489   Dali::LongPressGestureDetector result;
31490
31491   {
31492     try {
31493       result = Dali::LongPressGestureDetector::New();
31494     } catch (std::out_of_range& e) {
31495       {
31496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31497       };
31498     } catch (std::exception& e) {
31499       {
31500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31501       };
31502     } catch (Dali::DaliException e) {
31503       {
31504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31505       };
31506     } catch (...) {
31507       {
31508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31509       };
31510     }
31511   }
31512
31513   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31514   return jresult;
31515 }
31516
31517
31518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31519   void * jresult ;
31520   unsigned int arg1 ;
31521   Dali::LongPressGestureDetector result;
31522
31523   arg1 = (unsigned int)jarg1;
31524   {
31525     try {
31526       result = Dali::LongPressGestureDetector::New(arg1);
31527     } catch (std::out_of_range& e) {
31528       {
31529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31530       };
31531     } catch (std::exception& e) {
31532       {
31533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31534       };
31535     } catch (Dali::DaliException e) {
31536       {
31537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31538       };
31539     } catch (...) {
31540       {
31541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31542       };
31543     }
31544   }
31545
31546   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31547   return jresult;
31548 }
31549
31550
31551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31552   void * jresult ;
31553   unsigned int arg1 ;
31554   unsigned int arg2 ;
31555   Dali::LongPressGestureDetector result;
31556
31557   arg1 = (unsigned int)jarg1;
31558   arg2 = (unsigned int)jarg2;
31559   {
31560     try {
31561       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31562     } catch (std::out_of_range& e) {
31563       {
31564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31565       };
31566     } catch (std::exception& e) {
31567       {
31568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31569       };
31570     } catch (Dali::DaliException e) {
31571       {
31572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31573       };
31574     } catch (...) {
31575       {
31576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31577       };
31578     }
31579   }
31580
31581   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31582   return jresult;
31583 }
31584
31585
31586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31587   void * jresult ;
31588   Dali::BaseHandle arg1 ;
31589   Dali::BaseHandle *argp1 ;
31590   Dali::LongPressGestureDetector result;
31591
31592   argp1 = (Dali::BaseHandle *)jarg1;
31593   if (!argp1) {
31594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31595     return 0;
31596   }
31597   arg1 = *argp1;
31598   {
31599     try {
31600       result = Dali::LongPressGestureDetector::DownCast(arg1);
31601     } catch (std::out_of_range& e) {
31602       {
31603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31604       };
31605     } catch (std::exception& e) {
31606       {
31607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31608       };
31609     } catch (Dali::DaliException e) {
31610       {
31611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31612       };
31613     } catch (...) {
31614       {
31615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31616       };
31617     }
31618   }
31619
31620   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31621   return jresult;
31622 }
31623
31624
31625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31626   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31627
31628   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31629   {
31630     try {
31631       delete arg1;
31632     } catch (std::out_of_range& e) {
31633       {
31634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31635       };
31636     } catch (std::exception& e) {
31637       {
31638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31639       };
31640     } catch (Dali::DaliException e) {
31641       {
31642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31643       };
31644     } catch (...) {
31645       {
31646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31647       };
31648     }
31649   }
31650
31651 }
31652
31653
31654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31655   void * jresult ;
31656   Dali::LongPressGestureDetector *arg1 = 0 ;
31657   Dali::LongPressGestureDetector *result = 0 ;
31658
31659   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31660   if (!arg1) {
31661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31662     return 0;
31663   }
31664   {
31665     try {
31666       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31667     } catch (std::out_of_range& e) {
31668       {
31669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31670       };
31671     } catch (std::exception& e) {
31672       {
31673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31674       };
31675     } catch (Dali::DaliException e) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31678       };
31679     } catch (...) {
31680       {
31681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31682       };
31683     }
31684   }
31685
31686   jresult = (void *)result;
31687   return jresult;
31688 }
31689
31690
31691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31692   void * jresult ;
31693   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31694   Dali::LongPressGestureDetector *arg2 = 0 ;
31695   Dali::LongPressGestureDetector *result = 0 ;
31696
31697   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31698   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31699   if (!arg2) {
31700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31701     return 0;
31702   }
31703   {
31704     try {
31705       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31706     } catch (std::out_of_range& e) {
31707       {
31708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (std::exception& e) {
31711       {
31712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31713       };
31714     } catch (Dali::DaliException e) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31717       };
31718     } catch (...) {
31719       {
31720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31721       };
31722     }
31723   }
31724
31725   jresult = (void *)result;
31726   return jresult;
31727 }
31728
31729
31730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31731   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31732   unsigned int arg2 ;
31733
31734   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31735   arg2 = (unsigned int)jarg2;
31736   {
31737     try {
31738       (arg1)->SetTouchesRequired(arg2);
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31746       };
31747     } catch (Dali::DaliException e) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31750       };
31751     } catch (...) {
31752       {
31753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31754       };
31755     }
31756   }
31757
31758 }
31759
31760
31761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31762   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31763   unsigned int arg2 ;
31764   unsigned int arg3 ;
31765
31766   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31767   arg2 = (unsigned int)jarg2;
31768   arg3 = (unsigned int)jarg3;
31769   {
31770     try {
31771       (arg1)->SetTouchesRequired(arg2,arg3);
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31779       };
31780     } catch (Dali::DaliException e) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31783       };
31784     } catch (...) {
31785       {
31786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31787       };
31788     }
31789   }
31790
31791 }
31792
31793
31794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31795   unsigned int jresult ;
31796   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31797   unsigned int result;
31798
31799   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31800   {
31801     try {
31802       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31803     } catch (std::out_of_range& e) {
31804       {
31805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31806       };
31807     } catch (std::exception& e) {
31808       {
31809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31810       };
31811     } catch (Dali::DaliException e) {
31812       {
31813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31814       };
31815     } catch (...) {
31816       {
31817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31818       };
31819     }
31820   }
31821
31822   jresult = result;
31823   return jresult;
31824 }
31825
31826
31827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31828   unsigned int jresult ;
31829   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31830   unsigned int result;
31831
31832   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31833   {
31834     try {
31835       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31836     } catch (std::out_of_range& e) {
31837       {
31838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31839       };
31840     } catch (std::exception& e) {
31841       {
31842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31843       };
31844     } catch (Dali::DaliException e) {
31845       {
31846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31847       };
31848     } catch (...) {
31849       {
31850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31851       };
31852     }
31853   }
31854
31855   jresult = result;
31856   return jresult;
31857 }
31858
31859
31860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31861   void * jresult ;
31862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31863   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31864
31865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31866   {
31867     try {
31868       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31869     } catch (std::out_of_range& e) {
31870       {
31871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (std::exception& e) {
31874       {
31875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31876       };
31877     } catch (Dali::DaliException e) {
31878       {
31879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31880       };
31881     } catch (...) {
31882       {
31883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31884       };
31885     }
31886   }
31887
31888   jresult = (void *)result;
31889   return jresult;
31890 }
31891
31892
31893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31894   void * jresult ;
31895   Dali::Gesture::State arg1 ;
31896   Dali::LongPressGesture *result = 0 ;
31897
31898   arg1 = (Dali::Gesture::State)jarg1;
31899   {
31900     try {
31901       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31902     } catch (std::out_of_range& e) {
31903       {
31904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31905       };
31906     } catch (std::exception& e) {
31907       {
31908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31909       };
31910     } catch (Dali::DaliException e) {
31911       {
31912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31913       };
31914     } catch (...) {
31915       {
31916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31917       };
31918     }
31919   }
31920
31921   jresult = (void *)result;
31922   return jresult;
31923 }
31924
31925
31926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31927   void * jresult ;
31928   Dali::LongPressGesture *arg1 = 0 ;
31929   Dali::LongPressGesture *result = 0 ;
31930
31931   arg1 = (Dali::LongPressGesture *)jarg1;
31932   if (!arg1) {
31933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31934     return 0;
31935   }
31936   {
31937     try {
31938       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31939     } catch (std::out_of_range& e) {
31940       {
31941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31942       };
31943     } catch (std::exception& e) {
31944       {
31945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31946       };
31947     } catch (Dali::DaliException e) {
31948       {
31949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31950       };
31951     } catch (...) {
31952       {
31953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31954       };
31955     }
31956   }
31957
31958   jresult = (void *)result;
31959   return jresult;
31960 }
31961
31962
31963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31964   void * jresult ;
31965   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31966   Dali::LongPressGesture *arg2 = 0 ;
31967   Dali::LongPressGesture *result = 0 ;
31968
31969   arg1 = (Dali::LongPressGesture *)jarg1;
31970   arg2 = (Dali::LongPressGesture *)jarg2;
31971   if (!arg2) {
31972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31973     return 0;
31974   }
31975   {
31976     try {
31977       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31978     } catch (std::out_of_range& e) {
31979       {
31980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31981       };
31982     } catch (std::exception& e) {
31983       {
31984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31985       };
31986     } catch (Dali::DaliException e) {
31987       {
31988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31989       };
31990     } catch (...) {
31991       {
31992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31993       };
31994     }
31995   }
31996
31997   jresult = (void *)result;
31998   return jresult;
31999 }
32000
32001
32002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32003   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32004
32005   arg1 = (Dali::LongPressGesture *)jarg1;
32006   {
32007     try {
32008       delete arg1;
32009     } catch (std::out_of_range& e) {
32010       {
32011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (std::exception& e) {
32014       {
32015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32016       };
32017     } catch (Dali::DaliException e) {
32018       {
32019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32020       };
32021     } catch (...) {
32022       {
32023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32024       };
32025     }
32026   }
32027
32028 }
32029
32030
32031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32032   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32033   unsigned int arg2 ;
32034
32035   arg1 = (Dali::LongPressGesture *)jarg1;
32036   arg2 = (unsigned int)jarg2;
32037   if (arg1) (arg1)->numberOfTouches = arg2;
32038 }
32039
32040
32041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32042   unsigned int jresult ;
32043   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32044   unsigned int result;
32045
32046   arg1 = (Dali::LongPressGesture *)jarg1;
32047   result = (unsigned int) ((arg1)->numberOfTouches);
32048   jresult = result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32054   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32055   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32056
32057   arg1 = (Dali::LongPressGesture *)jarg1;
32058   arg2 = (Dali::Vector2 *)jarg2;
32059   if (arg1) (arg1)->screenPoint = *arg2;
32060 }
32061
32062
32063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32064   void * jresult ;
32065   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32066   Dali::Vector2 *result = 0 ;
32067
32068   arg1 = (Dali::LongPressGesture *)jarg1;
32069   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32070   jresult = (void *)result;
32071   return jresult;
32072 }
32073
32074
32075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32076   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32077   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32078
32079   arg1 = (Dali::LongPressGesture *)jarg1;
32080   arg2 = (Dali::Vector2 *)jarg2;
32081   if (arg1) (arg1)->localPoint = *arg2;
32082 }
32083
32084
32085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32086   void * jresult ;
32087   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32088   Dali::Vector2 *result = 0 ;
32089
32090   arg1 = (Dali::LongPressGesture *)jarg1;
32091   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32092   jresult = (void *)result;
32093   return jresult;
32094 }
32095
32096
32097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32098   void * jresult ;
32099   Dali::WheelEvent *result = 0 ;
32100
32101   {
32102     try {
32103       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32104     } catch (std::out_of_range& e) {
32105       {
32106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32107       };
32108     } catch (std::exception& e) {
32109       {
32110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32111       };
32112     } catch (Dali::DaliException e) {
32113       {
32114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32115       };
32116     } catch (...) {
32117       {
32118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32119       };
32120     }
32121   }
32122
32123   jresult = (void *)result;
32124   return jresult;
32125 }
32126
32127
32128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32129   void * jresult ;
32130   Dali::WheelEvent::Type arg1 ;
32131   int arg2 ;
32132   unsigned int arg3 ;
32133   Dali::Vector2 arg4 ;
32134   int arg5 ;
32135   unsigned int arg6 ;
32136   Dali::Vector2 *argp4 ;
32137   Dali::WheelEvent *result = 0 ;
32138
32139   arg1 = (Dali::WheelEvent::Type)jarg1;
32140   arg2 = (int)jarg2;
32141   arg3 = (unsigned int)jarg3;
32142   argp4 = (Dali::Vector2 *)jarg4;
32143   if (!argp4) {
32144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32145     return 0;
32146   }
32147   arg4 = *argp4;
32148   arg5 = (int)jarg5;
32149   arg6 = (unsigned int)jarg6;
32150   {
32151     try {
32152       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32153     } catch (std::out_of_range& e) {
32154       {
32155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32156       };
32157     } catch (std::exception& e) {
32158       {
32159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32160       };
32161     } catch (Dali::DaliException e) {
32162       {
32163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32164       };
32165     } catch (...) {
32166       {
32167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32168       };
32169     }
32170   }
32171
32172   jresult = (void *)result;
32173   return jresult;
32174 }
32175
32176
32177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32178   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32179
32180   arg1 = (Dali::WheelEvent *)jarg1;
32181   {
32182     try {
32183       delete arg1;
32184     } catch (std::out_of_range& e) {
32185       {
32186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32187       };
32188     } catch (std::exception& e) {
32189       {
32190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32191       };
32192     } catch (Dali::DaliException e) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32195       };
32196     } catch (...) {
32197       {
32198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32199       };
32200     }
32201   }
32202
32203 }
32204
32205
32206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32207   unsigned int jresult ;
32208   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32209   bool result;
32210
32211   arg1 = (Dali::WheelEvent *)jarg1;
32212   {
32213     try {
32214       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32215     } catch (std::out_of_range& e) {
32216       {
32217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32218       };
32219     } catch (std::exception& e) {
32220       {
32221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32222       };
32223     } catch (Dali::DaliException e) {
32224       {
32225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32226       };
32227     } catch (...) {
32228       {
32229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32230       };
32231     }
32232   }
32233
32234   jresult = result;
32235   return jresult;
32236 }
32237
32238
32239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32240   unsigned int jresult ;
32241   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32242   bool result;
32243
32244   arg1 = (Dali::WheelEvent *)jarg1;
32245   {
32246     try {
32247       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32248     } catch (std::out_of_range& e) {
32249       {
32250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32251       };
32252     } catch (std::exception& e) {
32253       {
32254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (Dali::DaliException e) {
32257       {
32258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32259       };
32260     } catch (...) {
32261       {
32262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32263       };
32264     }
32265   }
32266
32267   jresult = result;
32268   return jresult;
32269 }
32270
32271
32272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32273   unsigned int jresult ;
32274   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32275   bool result;
32276
32277   arg1 = (Dali::WheelEvent *)jarg1;
32278   {
32279     try {
32280       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32281     } catch (std::out_of_range& e) {
32282       {
32283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32284       };
32285     } catch (std::exception& e) {
32286       {
32287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32288       };
32289     } catch (Dali::DaliException e) {
32290       {
32291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32292       };
32293     } catch (...) {
32294       {
32295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32296       };
32297     }
32298   }
32299
32300   jresult = result;
32301   return jresult;
32302 }
32303
32304
32305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32307   Dali::WheelEvent::Type arg2 ;
32308
32309   arg1 = (Dali::WheelEvent *)jarg1;
32310   arg2 = (Dali::WheelEvent::Type)jarg2;
32311   if (arg1) (arg1)->type = arg2;
32312 }
32313
32314
32315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32316   int jresult ;
32317   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32318   Dali::WheelEvent::Type result;
32319
32320   arg1 = (Dali::WheelEvent *)jarg1;
32321   result = (Dali::WheelEvent::Type) ((arg1)->type);
32322   jresult = (int)result;
32323   return jresult;
32324 }
32325
32326
32327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32329   int arg2 ;
32330
32331   arg1 = (Dali::WheelEvent *)jarg1;
32332   arg2 = (int)jarg2;
32333   if (arg1) (arg1)->direction = arg2;
32334 }
32335
32336
32337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32338   int jresult ;
32339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32340   int result;
32341
32342   arg1 = (Dali::WheelEvent *)jarg1;
32343   result = (int) ((arg1)->direction);
32344   jresult = result;
32345   return jresult;
32346 }
32347
32348
32349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32351   unsigned int arg2 ;
32352
32353   arg1 = (Dali::WheelEvent *)jarg1;
32354   arg2 = (unsigned int)jarg2;
32355   if (arg1) (arg1)->modifiers = arg2;
32356 }
32357
32358
32359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32360   unsigned int jresult ;
32361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32362   unsigned int result;
32363
32364   arg1 = (Dali::WheelEvent *)jarg1;
32365   result = (unsigned int) ((arg1)->modifiers);
32366   jresult = result;
32367   return jresult;
32368 }
32369
32370
32371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32373   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32374
32375   arg1 = (Dali::WheelEvent *)jarg1;
32376   arg2 = (Dali::Vector2 *)jarg2;
32377   if (arg1) (arg1)->point = *arg2;
32378 }
32379
32380
32381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32382   void * jresult ;
32383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32384   Dali::Vector2 *result = 0 ;
32385
32386   arg1 = (Dali::WheelEvent *)jarg1;
32387   result = (Dali::Vector2 *)& ((arg1)->point);
32388   jresult = (void *)result;
32389   return jresult;
32390 }
32391
32392
32393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32395   int arg2 ;
32396
32397   arg1 = (Dali::WheelEvent *)jarg1;
32398   arg2 = (int)jarg2;
32399   if (arg1) (arg1)->z = arg2;
32400 }
32401
32402
32403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32404   int jresult ;
32405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32406   int result;
32407
32408   arg1 = (Dali::WheelEvent *)jarg1;
32409   result = (int) ((arg1)->z);
32410   jresult = result;
32411   return jresult;
32412 }
32413
32414
32415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32417   unsigned int arg2 ;
32418
32419   arg1 = (Dali::WheelEvent *)jarg1;
32420   arg2 = (unsigned int)jarg2;
32421   if (arg1) (arg1)->timeStamp = arg2;
32422 }
32423
32424
32425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32426   unsigned int jresult ;
32427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32428   unsigned int result;
32429
32430   arg1 = (Dali::WheelEvent *)jarg1;
32431   result = (unsigned int) ((arg1)->timeStamp);
32432   jresult = result;
32433   return jresult;
32434 }
32435
32436 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32437   char * jresult ;
32438   Dali::KeyEvent *arg1 = 0 ;
32439   std::string result;
32440
32441   arg1 = (Dali::KeyEvent *)jarg1;
32442   if (!arg1) {
32443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32444     return 0;
32445   }
32446   {
32447     try {
32448       result = arg1->GetDeviceName();
32449     } catch (std::out_of_range& e) {
32450       {
32451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32452       };
32453     } catch (std::exception& e) {
32454       {
32455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32456       };
32457     } catch (Dali::DaliException e) {
32458       {
32459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32460       };
32461     } catch (...) {
32462       {
32463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32464       };
32465     }
32466   }
32467
32468   jresult = SWIG_csharp_string_callback((&result)->c_str());
32469   return jresult;
32470 }
32471
32472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32473   int jresult ;
32474   Dali::KeyEvent *arg1 = 0 ;
32475   Dali::Device::Class::Type result;
32476
32477   arg1 = (Dali::KeyEvent *)jarg1;
32478   if (!arg1) {
32479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32480     return 0;
32481   }
32482   {
32483     try {
32484       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32485     } catch (std::out_of_range& e) {
32486       {
32487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32488       };
32489     } catch (std::exception& e) {
32490       {
32491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32492       };
32493     } catch (Dali::DaliException e) {
32494       {
32495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32496       };
32497     } catch (...) {
32498       {
32499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32500       };
32501     }
32502   }
32503
32504   jresult = (int)result;
32505   return jresult;
32506 }
32507
32508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32509   int jresult ;
32510   Dali::KeyEvent *arg1 = 0 ;
32511   Dali::Device::Subclass::Type result;
32512
32513   arg1 = (Dali::KeyEvent *)jarg1;
32514   if (!arg1) {
32515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32516     return 0;
32517   }
32518   {
32519     try {
32520       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32521     } catch (std::out_of_range& e) {
32522       {
32523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32524       };
32525     } catch (std::exception& e) {
32526       {
32527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32528       };
32529     } catch (Dali::DaliException e) {
32530       {
32531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32532       };
32533     } catch (...) {
32534       {
32535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32536       };
32537     }
32538   }
32539
32540   jresult = (int)result;
32541   return jresult;
32542 }
32543
32544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32545   Dali::Actor arg1 ;
32546   Dali::Actor *argp1 ;
32547
32548   argp1 = (Dali::Actor *)jarg1;
32549   if (!argp1) {
32550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32551     return ;
32552   }
32553   arg1 = *argp1;
32554   {
32555     try {
32556       arg1.Raise();
32557     } catch (std::out_of_range& e) {
32558       {
32559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32560       };
32561     } catch (std::exception& e) {
32562       {
32563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32564       };
32565     } catch (Dali::DaliException e) {
32566       {
32567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32568       };
32569     } catch (...) {
32570       {
32571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32572       };
32573     }
32574   }
32575
32576 }
32577
32578
32579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32580   Dali::Actor arg1 ;
32581   Dali::Actor *argp1 ;
32582
32583   argp1 = (Dali::Actor *)jarg1;
32584   if (!argp1) {
32585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32586     return ;
32587   }
32588   arg1 = *argp1;
32589   {
32590     try {
32591       arg1.Lower();
32592     } catch (std::out_of_range& e) {
32593       {
32594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32595       };
32596     } catch (std::exception& e) {
32597       {
32598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32599       };
32600     } catch (Dali::DaliException e) {
32601       {
32602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32603       };
32604     } catch (...) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32607       };
32608     }
32609   }
32610
32611 }
32612
32613
32614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32615   Dali::Actor arg1 ;
32616   Dali::Actor *argp1 ;
32617
32618   argp1 = (Dali::Actor *)jarg1;
32619   if (!argp1) {
32620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32621     return ;
32622   }
32623   arg1 = *argp1;
32624   {
32625     try {
32626       arg1.RaiseToTop();
32627     } catch (std::out_of_range& e) {
32628       {
32629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (std::exception& e) {
32632       {
32633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32634       };
32635     } catch (Dali::DaliException e) {
32636       {
32637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32638       };
32639     } catch (...) {
32640       {
32641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32642       };
32643     }
32644   }
32645
32646 }
32647
32648
32649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32650   Dali::Actor arg1 ;
32651   Dali::Actor *argp1 ;
32652
32653   argp1 = (Dali::Actor *)jarg1;
32654   if (!argp1) {
32655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32656     return ;
32657   }
32658   arg1 = *argp1;
32659   {
32660     try {
32661       arg1.LowerToBottom();
32662     } catch (std::out_of_range& e) {
32663       {
32664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (std::exception& e) {
32667       {
32668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32669       };
32670     } catch (Dali::DaliException e) {
32671       {
32672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32673       };
32674     } catch (...) {
32675       {
32676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32677       };
32678     }
32679   }
32680
32681 }
32682
32683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32684   Dali::Actor arg1 ;
32685   Dali::Actor arg2 ;
32686   Dali::Actor *argp1 ;
32687   Dali::Actor *argp2 ;
32688
32689   argp1 = (Dali::Actor *)jarg1;
32690   if (!argp1) {
32691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32692     return ;
32693   }
32694   arg1 = *argp1;
32695   argp2 = (Dali::Actor *)jarg2;
32696   if (!argp2) {
32697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32698     return ;
32699   }
32700   arg2 = *argp2;
32701   {
32702     try {
32703       arg1.RaiseAbove(arg2);
32704     } catch (std::out_of_range& e) {
32705       {
32706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32707       };
32708     } catch (std::exception& e) {
32709       {
32710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32711       };
32712     } catch (Dali::DaliException e) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32715       };
32716     } catch (...) {
32717       {
32718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32719       };
32720     }
32721   }
32722
32723 }
32724
32725
32726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32727   Dali::Actor arg1 ;
32728   Dali::Actor arg2 ;
32729   Dali::Actor *argp1 ;
32730   Dali::Actor *argp2 ;
32731
32732   argp1 = (Dali::Actor *)jarg1;
32733   if (!argp1) {
32734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32735     return ;
32736   }
32737   arg1 = *argp1;
32738   argp2 = (Dali::Actor *)jarg2;
32739   if (!argp2) {
32740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32741     return ;
32742   }
32743   arg2 = *argp2;
32744   {
32745     try {
32746       arg1.LowerBelow(arg2);
32747     } catch (std::out_of_range& e) {
32748       {
32749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32750       };
32751     } catch (std::exception& e) {
32752       {
32753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32754       };
32755     } catch (Dali::DaliException e) {
32756       {
32757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32758       };
32759     } catch (...) {
32760       {
32761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32762       };
32763     }
32764   }
32765
32766 }
32767
32768
32769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32770   void * jresult ;
32771   Dali::Actor arg1 ;
32772   Dali::Actor *argp1 ;
32773   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32774
32775   argp1 = (Dali::Actor *)jarg1;
32776   if (!argp1) {
32777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32778     return 0;
32779   }
32780   arg1 = *argp1;
32781   {
32782     try {
32783       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32784     } catch (std::out_of_range& e) {
32785       {
32786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32787       };
32788     } catch (std::exception& e) {
32789       {
32790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32791       };
32792     } catch (Dali::DaliException e) {
32793       {
32794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32795       };
32796     } catch (...) {
32797       {
32798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32799       };
32800     }
32801   }
32802
32803   jresult = (void *)result;
32804   return jresult;
32805 }
32806
32807
32808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32809   void * jresult ;
32810   Dali::Actor *arg1 ;
32811   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32812
32813   arg1 = (Dali::Actor *)jarg1;
32814   {
32815     try {
32816       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32817     } catch (std::out_of_range& e) {
32818       {
32819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32820       };
32821     } catch (std::exception& e) {
32822       {
32823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32824       };
32825     } catch (Dali::DaliException e) {
32826       {
32827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32828       };
32829     } catch (...) {
32830       {
32831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32832       };
32833     }
32834   }
32835
32836   jresult = (void *)result;
32837   return jresult;
32838 }
32839
32840
32841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32842   int jresult ;
32843   int result;
32844
32845   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32846   jresult = (int)result;
32847   return jresult;
32848 }
32849
32850
32851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32852   int jresult ;
32853   int result;
32854
32855   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32856   jresult = (int)result;
32857   return jresult;
32858 }
32859
32860
32861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32862   int jresult ;
32863   int result;
32864
32865   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32866   jresult = (int)result;
32867   return jresult;
32868 }
32869
32870
32871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32872   int jresult ;
32873   int result;
32874
32875   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32876   jresult = (int)result;
32877   return jresult;
32878 }
32879
32880
32881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32882   int jresult ;
32883   int result;
32884
32885   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32886   jresult = (int)result;
32887   return jresult;
32888 }
32889
32890
32891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32892   int jresult ;
32893   int result;
32894
32895   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32896   jresult = (int)result;
32897   return jresult;
32898 }
32899
32900
32901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32902   int jresult ;
32903   int result;
32904
32905   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32906   jresult = (int)result;
32907   return jresult;
32908 }
32909
32910
32911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32912   int jresult ;
32913   int result;
32914
32915   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32916   jresult = (int)result;
32917   return jresult;
32918 }
32919
32920
32921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32922   int jresult ;
32923   int result;
32924
32925   result = (int)Dali::Actor::Property::SIZE;
32926   jresult = (int)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::POSITION;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::POSITION_X;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::POSITION_Y;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::POSITION_Z;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::WORLD_POSITION;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::ORIENTATION;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::SCALE;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::SCALE_X;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::SCALE_Y;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::SCALE_Z;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WORLD_SCALE;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::VISIBLE;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::COLOR;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::COLOR_RED;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::COLOR_GREEN;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::COLOR_BLUE;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::WORLD_COLOR;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::NAME;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::SENSITIVE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::COLOR_MODE;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::DRAW_MODE;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::PADDING;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33372   void * jresult ;
33373   Dali::Actor::Property *result = 0 ;
33374
33375   {
33376     try {
33377       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33378     } catch (std::out_of_range& e) {
33379       {
33380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33381       };
33382     } catch (std::exception& e) {
33383       {
33384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33385       };
33386     } catch (Dali::DaliException e) {
33387       {
33388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33389       };
33390     } catch (...) {
33391       {
33392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33393       };
33394     }
33395   }
33396
33397   jresult = (void *)result;
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33403   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33404
33405   arg1 = (Dali::Actor::Property *)jarg1;
33406   {
33407     try {
33408       delete arg1;
33409     } catch (std::out_of_range& e) {
33410       {
33411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33412       };
33413     } catch (std::exception& e) {
33414       {
33415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33416       };
33417     } catch (Dali::DaliException e) {
33418       {
33419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33420       };
33421     } catch (...) {
33422       {
33423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33424       };
33425     }
33426   }
33427
33428 }
33429
33430
33431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33432   void * jresult ;
33433   Dali::Actor *result = 0 ;
33434
33435   {
33436     try {
33437       result = (Dali::Actor *)new Dali::Actor();
33438     } catch (std::out_of_range& e) {
33439       {
33440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33441       };
33442     } catch (std::exception& e) {
33443       {
33444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33445       };
33446     } catch (Dali::DaliException e) {
33447       {
33448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33449       };
33450     } catch (...) {
33451       {
33452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33453       };
33454     }
33455   }
33456
33457   jresult = (void *)result;
33458   return jresult;
33459 }
33460
33461
33462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33463   void * jresult ;
33464   Dali::Actor result;
33465
33466   {
33467     try {
33468       result = Dali::Actor::New();
33469     } catch (std::out_of_range& e) {
33470       {
33471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33472       };
33473     } catch (std::exception& e) {
33474       {
33475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (Dali::DaliException e) {
33478       {
33479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487
33488   jresult = new Dali::Actor((const Dali::Actor &)result);
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33494   void * jresult ;
33495   Dali::BaseHandle arg1 ;
33496   Dali::BaseHandle *argp1 ;
33497   Dali::Actor result;
33498
33499   argp1 = (Dali::BaseHandle *)jarg1;
33500   if (!argp1) {
33501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33502     return 0;
33503   }
33504   arg1 = *argp1;
33505   {
33506     try {
33507       result = Dali::Actor::DownCast(arg1);
33508     } catch (std::out_of_range& e) {
33509       {
33510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33511       };
33512     } catch (std::exception& e) {
33513       {
33514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33515       };
33516     } catch (Dali::DaliException e) {
33517       {
33518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33519       };
33520     } catch (...) {
33521       {
33522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33523       };
33524     }
33525   }
33526
33527   jresult = new Dali::Actor((const Dali::Actor &)result);
33528   return jresult;
33529 }
33530
33531
33532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33533   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33534
33535   arg1 = (Dali::Actor *)jarg1;
33536   {
33537     try {
33538       delete arg1;
33539     } catch (std::out_of_range& e) {
33540       {
33541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33542       };
33543     } catch (std::exception& e) {
33544       {
33545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33546       };
33547     } catch (Dali::DaliException e) {
33548       {
33549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33550       };
33551     } catch (...) {
33552       {
33553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33554       };
33555     }
33556   }
33557
33558 }
33559
33560
33561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33562   void * jresult ;
33563   Dali::Actor *arg1 = 0 ;
33564   Dali::Actor *result = 0 ;
33565
33566   arg1 = (Dali::Actor *)jarg1;
33567   if (!arg1) {
33568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33569     return 0;
33570   }
33571   {
33572     try {
33573       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33574     } catch (std::out_of_range& e) {
33575       {
33576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33577       };
33578     } catch (std::exception& e) {
33579       {
33580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33581       };
33582     } catch (Dali::DaliException e) {
33583       {
33584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33585       };
33586     } catch (...) {
33587       {
33588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33589       };
33590     }
33591   }
33592
33593   jresult = (void *)result;
33594   return jresult;
33595 }
33596
33597
33598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33599   void * jresult ;
33600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33601   Dali::Actor *arg2 = 0 ;
33602   Dali::Actor *result = 0 ;
33603
33604   arg1 = (Dali::Actor *)jarg1;
33605   arg2 = (Dali::Actor *)jarg2;
33606   if (!arg2) {
33607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33608     return 0;
33609   }
33610   {
33611     try {
33612       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33613     } catch (std::out_of_range& e) {
33614       {
33615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33616       };
33617     } catch (std::exception& e) {
33618       {
33619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33620       };
33621     } catch (Dali::DaliException e) {
33622       {
33623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33624       };
33625     } catch (...) {
33626       {
33627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33628       };
33629     }
33630   }
33631
33632   jresult = (void *)result;
33633   return jresult;
33634 }
33635
33636
33637 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33638   char * jresult ;
33639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33640   std::string *result = 0 ;
33641
33642   arg1 = (Dali::Actor *)jarg1;
33643   {
33644     try {
33645       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33646     } catch (std::out_of_range& e) {
33647       {
33648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33649       };
33650     } catch (std::exception& e) {
33651       {
33652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33653       };
33654     } catch (Dali::DaliException e) {
33655       {
33656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33657       };
33658     } catch (...) {
33659       {
33660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33661       };
33662     }
33663   }
33664
33665   jresult = SWIG_csharp_string_callback(result->c_str());
33666   return jresult;
33667 }
33668
33669
33670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33672   std::string *arg2 = 0 ;
33673
33674   arg1 = (Dali::Actor *)jarg1;
33675   if (!jarg2) {
33676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33677     return ;
33678   }
33679   std::string arg2_str(jarg2);
33680   arg2 = &arg2_str;
33681   {
33682     try {
33683       (arg1)->SetName((std::string const &)*arg2);
33684     } catch (std::out_of_range& e) {
33685       {
33686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33687       };
33688     } catch (std::exception& e) {
33689       {
33690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33691       };
33692     } catch (Dali::DaliException e) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33695       };
33696     } catch (...) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33699       };
33700     }
33701   }
33702
33703
33704   //argout typemap for const std::string&
33705
33706 }
33707
33708
33709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33710   unsigned int jresult ;
33711   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33712   unsigned int result;
33713
33714   arg1 = (Dali::Actor *)jarg1;
33715   {
33716     try {
33717       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33718     } catch (std::out_of_range& e) {
33719       {
33720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33721       };
33722     } catch (std::exception& e) {
33723       {
33724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33725       };
33726     } catch (Dali::DaliException e) {
33727       {
33728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33733       };
33734     }
33735   }
33736
33737   jresult = result;
33738   return jresult;
33739 }
33740
33741
33742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33743   unsigned int jresult ;
33744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33745   bool result;
33746
33747   arg1 = (Dali::Actor *)jarg1;
33748   {
33749     try {
33750       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33751     } catch (std::out_of_range& e) {
33752       {
33753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33754       };
33755     } catch (std::exception& e) {
33756       {
33757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33758       };
33759     } catch (Dali::DaliException e) {
33760       {
33761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33762       };
33763     } catch (...) {
33764       {
33765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33766       };
33767     }
33768   }
33769
33770   jresult = result;
33771   return jresult;
33772 }
33773
33774
33775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33776   unsigned int jresult ;
33777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33778   bool result;
33779
33780   arg1 = (Dali::Actor *)jarg1;
33781   {
33782     try {
33783       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33784     } catch (std::out_of_range& e) {
33785       {
33786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33787       };
33788     } catch (std::exception& e) {
33789       {
33790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33791       };
33792     } catch (Dali::DaliException e) {
33793       {
33794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33795       };
33796     } catch (...) {
33797       {
33798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33799       };
33800     }
33801   }
33802
33803   jresult = result;
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33809   unsigned int jresult ;
33810   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33811   bool result;
33812
33813   arg1 = (Dali::Actor *)jarg1;
33814   {
33815     try {
33816       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33817     } catch (std::out_of_range& e) {
33818       {
33819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33820       };
33821     } catch (std::exception& e) {
33822       {
33823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (Dali::DaliException e) {
33826       {
33827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33828       };
33829     } catch (...) {
33830       {
33831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33832       };
33833     }
33834   }
33835
33836   jresult = result;
33837   return jresult;
33838 }
33839
33840
33841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33842   void * jresult ;
33843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33844   Dali::Layer result;
33845
33846   arg1 = (Dali::Actor *)jarg1;
33847   {
33848     try {
33849       result = (arg1)->GetLayer();
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (Dali::DaliException e) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33861       };
33862     } catch (...) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33865       };
33866     }
33867   }
33868
33869   jresult = new Dali::Layer((const Dali::Layer &)result);
33870   return jresult;
33871 }
33872
33873
33874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33876   Dali::Actor arg2 ;
33877   Dali::Actor *argp2 ;
33878
33879   arg1 = (Dali::Actor *)jarg1;
33880   argp2 = (Dali::Actor *)jarg2;
33881   if (!argp2) {
33882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33883     return ;
33884   }
33885   arg2 = *argp2;
33886   {
33887     try {
33888       (arg1)->Add(arg2);
33889     } catch (std::out_of_range& e) {
33890       {
33891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33892       };
33893     } catch (std::exception& e) {
33894       {
33895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33896       };
33897     } catch (Dali::DaliException e) {
33898       {
33899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33900       };
33901     } catch (...) {
33902       {
33903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33904       };
33905     }
33906   }
33907
33908 }
33909
33910
33911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33913   Dali::Actor arg2 ;
33914   Dali::Actor *argp2 ;
33915
33916   arg1 = (Dali::Actor *)jarg1;
33917   argp2 = (Dali::Actor *)jarg2;
33918   if (!argp2) {
33919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33920     return ;
33921   }
33922   arg2 = *argp2;
33923   {
33924     try {
33925       (arg1)->Remove(arg2);
33926     } catch (std::out_of_range& e) {
33927       {
33928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33929       };
33930     } catch (std::exception& e) {
33931       {
33932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33933       };
33934     } catch (Dali::DaliException e) {
33935       {
33936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33937       };
33938     } catch (...) {
33939       {
33940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33941       };
33942     }
33943   }
33944
33945 }
33946
33947
33948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33950
33951   arg1 = (Dali::Actor *)jarg1;
33952   {
33953     try {
33954       (arg1)->Unparent();
33955     } catch (std::out_of_range& e) {
33956       {
33957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33958       };
33959     } catch (std::exception& e) {
33960       {
33961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33962       };
33963     } catch (Dali::DaliException e) {
33964       {
33965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33966       };
33967     } catch (...) {
33968       {
33969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33970       };
33971     }
33972   }
33973
33974 }
33975
33976
33977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33978   unsigned int jresult ;
33979   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33980   unsigned int result;
33981
33982   arg1 = (Dali::Actor *)jarg1;
33983   {
33984     try {
33985       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33986     } catch (std::out_of_range& e) {
33987       {
33988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (std::exception& e) {
33991       {
33992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (Dali::DaliException e) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33997       };
33998     } catch (...) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34001       };
34002     }
34003   }
34004
34005   jresult = result;
34006   return jresult;
34007 }
34008
34009
34010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34011   void * jresult ;
34012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34013   unsigned int arg2 ;
34014   Dali::Actor result;
34015
34016   arg1 = (Dali::Actor *)jarg1;
34017   arg2 = (unsigned int)jarg2;
34018   {
34019     try {
34020       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34021     } catch (std::out_of_range& e) {
34022       {
34023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34024       };
34025     } catch (std::exception& e) {
34026       {
34027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34028       };
34029     } catch (Dali::DaliException e) {
34030       {
34031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34032       };
34033     } catch (...) {
34034       {
34035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34036       };
34037     }
34038   }
34039
34040   jresult = new Dali::Actor((const Dali::Actor &)result);
34041   return jresult;
34042 }
34043
34044
34045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34046   void * jresult ;
34047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34048   std::string *arg2 = 0 ;
34049   Dali::Actor result;
34050
34051   arg1 = (Dali::Actor *)jarg1;
34052   if (!jarg2) {
34053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34054     return 0;
34055   }
34056   std::string arg2_str(jarg2);
34057   arg2 = &arg2_str;
34058   {
34059     try {
34060       result = (arg1)->FindChildByName((std::string const &)*arg2);
34061     } catch (std::out_of_range& e) {
34062       {
34063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34064       };
34065     } catch (std::exception& e) {
34066       {
34067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34068       };
34069     } catch (Dali::DaliException e) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34072       };
34073     } catch (...) {
34074       {
34075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34076       };
34077     }
34078   }
34079
34080   jresult = new Dali::Actor((const Dali::Actor &)result);
34081
34082   //argout typemap for const std::string&
34083
34084   return jresult;
34085 }
34086
34087
34088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34089   void * jresult ;
34090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34091   unsigned int arg2 ;
34092   Dali::Actor result;
34093
34094   arg1 = (Dali::Actor *)jarg1;
34095   arg2 = (unsigned int)jarg2;
34096   {
34097     try {
34098       result = (arg1)->FindChildById(arg2);
34099     } catch (std::out_of_range& e) {
34100       {
34101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (std::exception& e) {
34104       {
34105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34106       };
34107     } catch (Dali::DaliException e) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34110       };
34111     } catch (...) {
34112       {
34113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34114       };
34115     }
34116   }
34117
34118   jresult = new Dali::Actor((const Dali::Actor &)result);
34119   return jresult;
34120 }
34121
34122
34123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34124   void * jresult ;
34125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34126   Dali::Actor result;
34127
34128   arg1 = (Dali::Actor *)jarg1;
34129   {
34130     try {
34131       result = ((Dali::Actor const *)arg1)->GetParent();
34132     } catch (std::out_of_range& e) {
34133       {
34134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34135       };
34136     } catch (std::exception& e) {
34137       {
34138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34139       };
34140     } catch (Dali::DaliException e) {
34141       {
34142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34143       };
34144     } catch (...) {
34145       {
34146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34147       };
34148     }
34149   }
34150
34151   jresult = new Dali::Actor((const Dali::Actor &)result);
34152   return jresult;
34153 }
34154
34155
34156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34158   Dali::Vector3 *arg2 = 0 ;
34159
34160   arg1 = (Dali::Actor *)jarg1;
34161   arg2 = (Dali::Vector3 *)jarg2;
34162   if (!arg2) {
34163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34164     return ;
34165   }
34166   {
34167     try {
34168       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34169     } catch (std::out_of_range& e) {
34170       {
34171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34172       };
34173     } catch (std::exception& e) {
34174       {
34175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34176       };
34177     } catch (Dali::DaliException e) {
34178       {
34179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34180       };
34181     } catch (...) {
34182       {
34183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34184       };
34185     }
34186   }
34187
34188 }
34189
34190
34191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34192   void * jresult ;
34193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34194   Dali::Vector3 result;
34195
34196   arg1 = (Dali::Actor *)jarg1;
34197   {
34198     try {
34199       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34200     } catch (std::out_of_range& e) {
34201       {
34202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34203       };
34204     } catch (std::exception& e) {
34205       {
34206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34207       };
34208     } catch (Dali::DaliException e) {
34209       {
34210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34211       };
34212     } catch (...) {
34213       {
34214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34215       };
34216     }
34217   }
34218
34219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34220   return jresult;
34221 }
34222
34223
34224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34226   Dali::Vector3 *arg2 = 0 ;
34227
34228   arg1 = (Dali::Actor *)jarg1;
34229   arg2 = (Dali::Vector3 *)jarg2;
34230   if (!arg2) {
34231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34232     return ;
34233   }
34234   {
34235     try {
34236       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34237     } catch (std::out_of_range& e) {
34238       {
34239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34240       };
34241     } catch (std::exception& e) {
34242       {
34243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34244       };
34245     } catch (Dali::DaliException e) {
34246       {
34247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34248       };
34249     } catch (...) {
34250       {
34251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34252       };
34253     }
34254   }
34255
34256 }
34257
34258
34259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34260   void * jresult ;
34261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34262   Dali::Vector3 result;
34263
34264   arg1 = (Dali::Actor *)jarg1;
34265   {
34266     try {
34267       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (Dali::DaliException e) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34283       };
34284     }
34285   }
34286
34287   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34288   return jresult;
34289 }
34290
34291
34292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34294   float arg2 ;
34295   float arg3 ;
34296
34297   arg1 = (Dali::Actor *)jarg1;
34298   arg2 = (float)jarg2;
34299   arg3 = (float)jarg3;
34300   {
34301     try {
34302       (arg1)->SetSize(arg2,arg3);
34303     } catch (std::out_of_range& e) {
34304       {
34305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34306       };
34307     } catch (std::exception& e) {
34308       {
34309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34310       };
34311     } catch (Dali::DaliException e) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34314       };
34315     } catch (...) {
34316       {
34317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34318       };
34319     }
34320   }
34321
34322 }
34323
34324
34325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34327   float arg2 ;
34328   float arg3 ;
34329   float arg4 ;
34330
34331   arg1 = (Dali::Actor *)jarg1;
34332   arg2 = (float)jarg2;
34333   arg3 = (float)jarg3;
34334   arg4 = (float)jarg4;
34335   {
34336     try {
34337       (arg1)->SetSize(arg2,arg3,arg4);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34345       };
34346     } catch (Dali::DaliException e) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34349       };
34350     } catch (...) {
34351       {
34352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34353       };
34354     }
34355   }
34356
34357 }
34358
34359
34360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34362   Dali::Vector2 *arg2 = 0 ;
34363
34364   arg1 = (Dali::Actor *)jarg1;
34365   arg2 = (Dali::Vector2 *)jarg2;
34366   if (!arg2) {
34367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34368     return ;
34369   }
34370   {
34371     try {
34372       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34373     } catch (std::out_of_range& e) {
34374       {
34375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34376       };
34377     } catch (std::exception& e) {
34378       {
34379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34380       };
34381     } catch (Dali::DaliException e) {
34382       {
34383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34384       };
34385     } catch (...) {
34386       {
34387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34388       };
34389     }
34390   }
34391
34392 }
34393
34394
34395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34397   Dali::Vector3 *arg2 = 0 ;
34398
34399   arg1 = (Dali::Actor *)jarg1;
34400   arg2 = (Dali::Vector3 *)jarg2;
34401   if (!arg2) {
34402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34403     return ;
34404   }
34405   {
34406     try {
34407       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34408     } catch (std::out_of_range& e) {
34409       {
34410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34411       };
34412     } catch (std::exception& e) {
34413       {
34414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34415       };
34416     } catch (Dali::DaliException e) {
34417       {
34418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34419       };
34420     } catch (...) {
34421       {
34422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34423       };
34424     }
34425   }
34426
34427 }
34428
34429
34430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34431   void * jresult ;
34432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34433   Dali::Vector3 result;
34434
34435   arg1 = (Dali::Actor *)jarg1;
34436   {
34437     try {
34438       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34439     } catch (std::out_of_range& e) {
34440       {
34441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34442       };
34443     } catch (std::exception& e) {
34444       {
34445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34446       };
34447     } catch (Dali::DaliException e) {
34448       {
34449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34450       };
34451     } catch (...) {
34452       {
34453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34454       };
34455     }
34456   }
34457
34458   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34459   return jresult;
34460 }
34461
34462
34463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34464   void * jresult ;
34465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34466   Dali::Vector3 result;
34467
34468   arg1 = (Dali::Actor *)jarg1;
34469   {
34470     try {
34471       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34479       };
34480     } catch (Dali::DaliException e) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34483       };
34484     } catch (...) {
34485       {
34486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34487       };
34488     }
34489   }
34490
34491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34492   return jresult;
34493 }
34494
34495
34496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34497   void * jresult ;
34498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34499   Dali::Vector3 result;
34500
34501   arg1 = (Dali::Actor *)jarg1;
34502   {
34503     try {
34504       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34505     } catch (std::out_of_range& e) {
34506       {
34507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34508       };
34509     } catch (std::exception& e) {
34510       {
34511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34512       };
34513     } catch (Dali::DaliException e) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34516       };
34517     } catch (...) {
34518       {
34519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34520       };
34521     }
34522   }
34523
34524   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34525   return jresult;
34526 }
34527
34528
34529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34531   float arg2 ;
34532   float arg3 ;
34533
34534   arg1 = (Dali::Actor *)jarg1;
34535   arg2 = (float)jarg2;
34536   arg3 = (float)jarg3;
34537   {
34538     try {
34539       (arg1)->SetPosition(arg2,arg3);
34540     } catch (std::out_of_range& e) {
34541       {
34542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34543       };
34544     } catch (std::exception& e) {
34545       {
34546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (Dali::DaliException e) {
34549       {
34550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558
34559 }
34560
34561
34562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34564   float arg2 ;
34565   float arg3 ;
34566   float arg4 ;
34567
34568   arg1 = (Dali::Actor *)jarg1;
34569   arg2 = (float)jarg2;
34570   arg3 = (float)jarg3;
34571   arg4 = (float)jarg4;
34572   {
34573     try {
34574       (arg1)->SetPosition(arg2,arg3,arg4);
34575     } catch (std::out_of_range& e) {
34576       {
34577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34578       };
34579     } catch (std::exception& e) {
34580       {
34581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34582       };
34583     } catch (Dali::DaliException e) {
34584       {
34585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34590       };
34591     }
34592   }
34593
34594 }
34595
34596
34597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34599   Dali::Vector3 *arg2 = 0 ;
34600
34601   arg1 = (Dali::Actor *)jarg1;
34602   arg2 = (Dali::Vector3 *)jarg2;
34603   if (!arg2) {
34604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34605     return ;
34606   }
34607   {
34608     try {
34609       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34610     } catch (std::out_of_range& e) {
34611       {
34612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34613       };
34614     } catch (std::exception& e) {
34615       {
34616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34617       };
34618     } catch (Dali::DaliException e) {
34619       {
34620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34621       };
34622     } catch (...) {
34623       {
34624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34625       };
34626     }
34627   }
34628
34629 }
34630
34631
34632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34634   float arg2 ;
34635
34636   arg1 = (Dali::Actor *)jarg1;
34637   arg2 = (float)jarg2;
34638   {
34639     try {
34640       (arg1)->SetX(arg2);
34641     } catch (std::out_of_range& e) {
34642       {
34643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34644       };
34645     } catch (std::exception& e) {
34646       {
34647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34648       };
34649     } catch (Dali::DaliException e) {
34650       {
34651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34652       };
34653     } catch (...) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34656       };
34657     }
34658   }
34659
34660 }
34661
34662
34663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34664   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34665   float arg2 ;
34666
34667   arg1 = (Dali::Actor *)jarg1;
34668   arg2 = (float)jarg2;
34669   {
34670     try {
34671       (arg1)->SetY(arg2);
34672     } catch (std::out_of_range& e) {
34673       {
34674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34675       };
34676     } catch (std::exception& e) {
34677       {
34678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34679       };
34680     } catch (Dali::DaliException e) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34683       };
34684     } catch (...) {
34685       {
34686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34687       };
34688     }
34689   }
34690
34691 }
34692
34693
34694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34696   float arg2 ;
34697
34698   arg1 = (Dali::Actor *)jarg1;
34699   arg2 = (float)jarg2;
34700   {
34701     try {
34702       (arg1)->SetZ(arg2);
34703     } catch (std::out_of_range& e) {
34704       {
34705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34706       };
34707     } catch (std::exception& e) {
34708       {
34709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34710       };
34711     } catch (Dali::DaliException e) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34714       };
34715     } catch (...) {
34716       {
34717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34718       };
34719     }
34720   }
34721
34722 }
34723
34724
34725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34727   Dali::Vector3 *arg2 = 0 ;
34728
34729   arg1 = (Dali::Actor *)jarg1;
34730   arg2 = (Dali::Vector3 *)jarg2;
34731   if (!arg2) {
34732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34733     return ;
34734   }
34735   {
34736     try {
34737       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34738     } catch (std::out_of_range& e) {
34739       {
34740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34741       };
34742     } catch (std::exception& e) {
34743       {
34744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34745       };
34746     } catch (Dali::DaliException e) {
34747       {
34748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34749       };
34750     } catch (...) {
34751       {
34752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34753       };
34754     }
34755   }
34756
34757 }
34758
34759
34760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34761   void * jresult ;
34762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34763   Dali::Vector3 result;
34764
34765   arg1 = (Dali::Actor *)jarg1;
34766   {
34767     try {
34768       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34769     } catch (std::out_of_range& e) {
34770       {
34771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34772       };
34773     } catch (std::exception& e) {
34774       {
34775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34776       };
34777     } catch (Dali::DaliException e) {
34778       {
34779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34780       };
34781     } catch (...) {
34782       {
34783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34784       };
34785     }
34786   }
34787
34788   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34789   return jresult;
34790 }
34791
34792
34793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34794   void * jresult ;
34795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34796   Dali::Vector3 result;
34797
34798   arg1 = (Dali::Actor *)jarg1;
34799   {
34800     try {
34801       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34802     } catch (std::out_of_range& e) {
34803       {
34804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34805       };
34806     } catch (std::exception& e) {
34807       {
34808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34809       };
34810     } catch (Dali::DaliException e) {
34811       {
34812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34813       };
34814     } catch (...) {
34815       {
34816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34817       };
34818     }
34819   }
34820
34821   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34822   return jresult;
34823 }
34824
34825
34826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34828   bool arg2 ;
34829
34830   arg1 = (Dali::Actor *)jarg1;
34831   arg2 = jarg2 ? true : false;
34832   {
34833     try {
34834       (arg1)->SetInheritPosition(arg2);
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34842       };
34843     } catch (Dali::DaliException e) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34846       };
34847     } catch (...) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34850       };
34851     }
34852   }
34853
34854 }
34855
34856
34857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34858   unsigned int jresult ;
34859   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34860   bool result;
34861
34862   arg1 = (Dali::Actor *)jarg1;
34863   {
34864     try {
34865       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34866     } catch (std::out_of_range& e) {
34867       {
34868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34869       };
34870     } catch (std::exception& e) {
34871       {
34872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34873       };
34874     } catch (Dali::DaliException e) {
34875       {
34876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34877       };
34878     } catch (...) {
34879       {
34880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34881       };
34882     }
34883   }
34884
34885   jresult = result;
34886   return jresult;
34887 }
34888
34889
34890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34892   Dali::Degree *arg2 = 0 ;
34893   Dali::Vector3 *arg3 = 0 ;
34894
34895   arg1 = (Dali::Actor *)jarg1;
34896   arg2 = (Dali::Degree *)jarg2;
34897   if (!arg2) {
34898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34899     return ;
34900   }
34901   arg3 = (Dali::Vector3 *)jarg3;
34902   if (!arg3) {
34903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34904     return ;
34905   }
34906   {
34907     try {
34908       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34909     } catch (std::out_of_range& e) {
34910       {
34911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34912       };
34913     } catch (std::exception& e) {
34914       {
34915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34916       };
34917     } catch (Dali::DaliException e) {
34918       {
34919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34920       };
34921     } catch (...) {
34922       {
34923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34924       };
34925     }
34926   }
34927
34928 }
34929
34930
34931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34933   Dali::Radian *arg2 = 0 ;
34934   Dali::Vector3 *arg3 = 0 ;
34935
34936   arg1 = (Dali::Actor *)jarg1;
34937   arg2 = (Dali::Radian *)jarg2;
34938   if (!arg2) {
34939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34940     return ;
34941   }
34942   arg3 = (Dali::Vector3 *)jarg3;
34943   if (!arg3) {
34944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34945     return ;
34946   }
34947   {
34948     try {
34949       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34950     } catch (std::out_of_range& e) {
34951       {
34952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34953       };
34954     } catch (std::exception& e) {
34955       {
34956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34957       };
34958     } catch (Dali::DaliException e) {
34959       {
34960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34961       };
34962     } catch (...) {
34963       {
34964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34965       };
34966     }
34967   }
34968
34969 }
34970
34971
34972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34974   Dali::Quaternion *arg2 = 0 ;
34975
34976   arg1 = (Dali::Actor *)jarg1;
34977   arg2 = (Dali::Quaternion *)jarg2;
34978   if (!arg2) {
34979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34980     return ;
34981   }
34982   {
34983     try {
34984       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34985     } catch (std::out_of_range& e) {
34986       {
34987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34988       };
34989     } catch (std::exception& e) {
34990       {
34991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (Dali::DaliException e) {
34994       {
34995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34996       };
34997     } catch (...) {
34998       {
34999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35000       };
35001     }
35002   }
35003
35004 }
35005
35006
35007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35009   Dali::Degree *arg2 = 0 ;
35010   Dali::Vector3 *arg3 = 0 ;
35011
35012   arg1 = (Dali::Actor *)jarg1;
35013   arg2 = (Dali::Degree *)jarg2;
35014   if (!arg2) {
35015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35016     return ;
35017   }
35018   arg3 = (Dali::Vector3 *)jarg3;
35019   if (!arg3) {
35020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35021     return ;
35022   }
35023   {
35024     try {
35025       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35026     } catch (std::out_of_range& e) {
35027       {
35028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35029       };
35030     } catch (std::exception& e) {
35031       {
35032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35033       };
35034     } catch (Dali::DaliException e) {
35035       {
35036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35037       };
35038     } catch (...) {
35039       {
35040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35041       };
35042     }
35043   }
35044
35045 }
35046
35047
35048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35050   Dali::Radian *arg2 = 0 ;
35051   Dali::Vector3 *arg3 = 0 ;
35052
35053   arg1 = (Dali::Actor *)jarg1;
35054   arg2 = (Dali::Radian *)jarg2;
35055   if (!arg2) {
35056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35057     return ;
35058   }
35059   arg3 = (Dali::Vector3 *)jarg3;
35060   if (!arg3) {
35061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35062     return ;
35063   }
35064   {
35065     try {
35066       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35067     } catch (std::out_of_range& e) {
35068       {
35069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35070       };
35071     } catch (std::exception& e) {
35072       {
35073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35074       };
35075     } catch (Dali::DaliException e) {
35076       {
35077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35078       };
35079     } catch (...) {
35080       {
35081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35082       };
35083     }
35084   }
35085
35086 }
35087
35088
35089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35091   Dali::Quaternion *arg2 = 0 ;
35092
35093   arg1 = (Dali::Actor *)jarg1;
35094   arg2 = (Dali::Quaternion *)jarg2;
35095   if (!arg2) {
35096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35097     return ;
35098   }
35099   {
35100     try {
35101       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35102     } catch (std::out_of_range& e) {
35103       {
35104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35105       };
35106     } catch (std::exception& e) {
35107       {
35108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35109       };
35110     } catch (Dali::DaliException e) {
35111       {
35112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35113       };
35114     } catch (...) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35117       };
35118     }
35119   }
35120
35121 }
35122
35123
35124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35125   void * jresult ;
35126   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35127   Dali::Quaternion result;
35128
35129   arg1 = (Dali::Actor *)jarg1;
35130   {
35131     try {
35132       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35133     } catch (std::out_of_range& e) {
35134       {
35135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35136       };
35137     } catch (std::exception& e) {
35138       {
35139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35140       };
35141     } catch (Dali::DaliException e) {
35142       {
35143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35144       };
35145     } catch (...) {
35146       {
35147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35148       };
35149     }
35150   }
35151
35152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35153   return jresult;
35154 }
35155
35156
35157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35159   bool arg2 ;
35160
35161   arg1 = (Dali::Actor *)jarg1;
35162   arg2 = jarg2 ? true : false;
35163   {
35164     try {
35165       (arg1)->SetInheritOrientation(arg2);
35166     } catch (std::out_of_range& e) {
35167       {
35168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35169       };
35170     } catch (std::exception& e) {
35171       {
35172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35173       };
35174     } catch (Dali::DaliException e) {
35175       {
35176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35177       };
35178     } catch (...) {
35179       {
35180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35181       };
35182     }
35183   }
35184
35185 }
35186
35187
35188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35189   unsigned int jresult ;
35190   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35191   bool result;
35192
35193   arg1 = (Dali::Actor *)jarg1;
35194   {
35195     try {
35196       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35197     } catch (std::out_of_range& e) {
35198       {
35199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35200       };
35201     } catch (std::exception& e) {
35202       {
35203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35204       };
35205     } catch (Dali::DaliException e) {
35206       {
35207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35208       };
35209     } catch (...) {
35210       {
35211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35212       };
35213     }
35214   }
35215
35216   jresult = result;
35217   return jresult;
35218 }
35219
35220
35221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35222   void * jresult ;
35223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35224   Dali::Quaternion result;
35225
35226   arg1 = (Dali::Actor *)jarg1;
35227   {
35228     try {
35229       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35230     } catch (std::out_of_range& e) {
35231       {
35232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35233       };
35234     } catch (std::exception& e) {
35235       {
35236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35237       };
35238     } catch (Dali::DaliException e) {
35239       {
35240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35241       };
35242     } catch (...) {
35243       {
35244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35245       };
35246     }
35247   }
35248
35249   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35250   return jresult;
35251 }
35252
35253
35254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35256   float arg2 ;
35257
35258   arg1 = (Dali::Actor *)jarg1;
35259   arg2 = (float)jarg2;
35260   {
35261     try {
35262       (arg1)->SetScale(arg2);
35263     } catch (std::out_of_range& e) {
35264       {
35265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35266       };
35267     } catch (std::exception& e) {
35268       {
35269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35270       };
35271     } catch (Dali::DaliException e) {
35272       {
35273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35274       };
35275     } catch (...) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35278       };
35279     }
35280   }
35281
35282 }
35283
35284
35285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   float arg2 ;
35288   float arg3 ;
35289   float arg4 ;
35290
35291   arg1 = (Dali::Actor *)jarg1;
35292   arg2 = (float)jarg2;
35293   arg3 = (float)jarg3;
35294   arg4 = (float)jarg4;
35295   {
35296     try {
35297       (arg1)->SetScale(arg2,arg3,arg4);
35298     } catch (std::out_of_range& e) {
35299       {
35300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35301       };
35302     } catch (std::exception& e) {
35303       {
35304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35305       };
35306     } catch (Dali::DaliException e) {
35307       {
35308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35309       };
35310     } catch (...) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35313       };
35314     }
35315   }
35316
35317 }
35318
35319
35320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35322   Dali::Vector3 *arg2 = 0 ;
35323
35324   arg1 = (Dali::Actor *)jarg1;
35325   arg2 = (Dali::Vector3 *)jarg2;
35326   if (!arg2) {
35327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35328     return ;
35329   }
35330   {
35331     try {
35332       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (Dali::DaliException e) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35344       };
35345     } catch (...) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35348       };
35349     }
35350   }
35351
35352 }
35353
35354
35355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35357   Dali::Vector3 *arg2 = 0 ;
35358
35359   arg1 = (Dali::Actor *)jarg1;
35360   arg2 = (Dali::Vector3 *)jarg2;
35361   if (!arg2) {
35362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35363     return ;
35364   }
35365   {
35366     try {
35367       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35368     } catch (std::out_of_range& e) {
35369       {
35370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35371       };
35372     } catch (std::exception& e) {
35373       {
35374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35375       };
35376     } catch (Dali::DaliException e) {
35377       {
35378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35379       };
35380     } catch (...) {
35381       {
35382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35383       };
35384     }
35385   }
35386
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35391   void * jresult ;
35392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35393   Dali::Vector3 result;
35394
35395   arg1 = (Dali::Actor *)jarg1;
35396   {
35397     try {
35398       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35399     } catch (std::out_of_range& e) {
35400       {
35401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35402       };
35403     } catch (std::exception& e) {
35404       {
35405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35406       };
35407     } catch (Dali::DaliException e) {
35408       {
35409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35410       };
35411     } catch (...) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35414       };
35415     }
35416   }
35417
35418   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35419   return jresult;
35420 }
35421
35422
35423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35424   void * jresult ;
35425   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35426   Dali::Vector3 result;
35427
35428   arg1 = (Dali::Actor *)jarg1;
35429   {
35430     try {
35431       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35432     } catch (std::out_of_range& e) {
35433       {
35434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35435       };
35436     } catch (std::exception& e) {
35437       {
35438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35439       };
35440     } catch (Dali::DaliException e) {
35441       {
35442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35443       };
35444     } catch (...) {
35445       {
35446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35447       };
35448     }
35449   }
35450
35451   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35452   return jresult;
35453 }
35454
35455
35456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35458   bool arg2 ;
35459
35460   arg1 = (Dali::Actor *)jarg1;
35461   arg2 = jarg2 ? true : false;
35462   {
35463     try {
35464       (arg1)->SetInheritScale(arg2);
35465     } catch (std::out_of_range& e) {
35466       {
35467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35468       };
35469     } catch (std::exception& e) {
35470       {
35471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35472       };
35473     } catch (Dali::DaliException e) {
35474       {
35475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35476       };
35477     } catch (...) {
35478       {
35479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35480       };
35481     }
35482   }
35483
35484 }
35485
35486
35487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35488   unsigned int jresult ;
35489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35490   bool result;
35491
35492   arg1 = (Dali::Actor *)jarg1;
35493   {
35494     try {
35495       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35496     } catch (std::out_of_range& e) {
35497       {
35498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35499       };
35500     } catch (std::exception& e) {
35501       {
35502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35503       };
35504     } catch (Dali::DaliException e) {
35505       {
35506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35507       };
35508     } catch (...) {
35509       {
35510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35511       };
35512     }
35513   }
35514
35515   jresult = result;
35516   return jresult;
35517 }
35518
35519
35520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35521   void * jresult ;
35522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35523   Dali::Matrix result;
35524
35525   arg1 = (Dali::Actor *)jarg1;
35526   {
35527     try {
35528       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35529     } catch (std::out_of_range& e) {
35530       {
35531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35532       };
35533     } catch (std::exception& e) {
35534       {
35535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35536       };
35537     } catch (Dali::DaliException e) {
35538       {
35539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35540       };
35541     } catch (...) {
35542       {
35543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35544       };
35545     }
35546   }
35547
35548   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35549   return jresult;
35550 }
35551
35552
35553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35555   bool arg2 ;
35556
35557   arg1 = (Dali::Actor *)jarg1;
35558   arg2 = jarg2 ? true : false;
35559   {
35560     try {
35561       (arg1)->SetVisible(arg2);
35562     } catch (std::out_of_range& e) {
35563       {
35564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35565       };
35566     } catch (std::exception& e) {
35567       {
35568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35569       };
35570     } catch (Dali::DaliException e) {
35571       {
35572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35573       };
35574     } catch (...) {
35575       {
35576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35577       };
35578     }
35579   }
35580
35581 }
35582
35583
35584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35585   unsigned int jresult ;
35586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35587   bool result;
35588
35589   arg1 = (Dali::Actor *)jarg1;
35590   {
35591     try {
35592       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35593     } catch (std::out_of_range& e) {
35594       {
35595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35596       };
35597     } catch (std::exception& e) {
35598       {
35599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35600       };
35601     } catch (Dali::DaliException e) {
35602       {
35603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35604       };
35605     } catch (...) {
35606       {
35607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35608       };
35609     }
35610   }
35611
35612   jresult = result;
35613   return jresult;
35614 }
35615
35616
35617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35619   float arg2 ;
35620
35621   arg1 = (Dali::Actor *)jarg1;
35622   arg2 = (float)jarg2;
35623   {
35624     try {
35625       (arg1)->SetOpacity(arg2);
35626     } catch (std::out_of_range& e) {
35627       {
35628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35629       };
35630     } catch (std::exception& e) {
35631       {
35632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (Dali::DaliException e) {
35635       {
35636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35637       };
35638     } catch (...) {
35639       {
35640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35641       };
35642     }
35643   }
35644
35645 }
35646
35647
35648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35649   float jresult ;
35650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35651   float result;
35652
35653   arg1 = (Dali::Actor *)jarg1;
35654   {
35655     try {
35656       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35664       };
35665     } catch (Dali::DaliException e) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35668       };
35669     } catch (...) {
35670       {
35671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35672       };
35673     }
35674   }
35675
35676   jresult = result;
35677   return jresult;
35678 }
35679
35680
35681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35683   Dali::Vector4 *arg2 = 0 ;
35684
35685   arg1 = (Dali::Actor *)jarg1;
35686   arg2 = (Dali::Vector4 *)jarg2;
35687   if (!arg2) {
35688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35689     return ;
35690   }
35691   {
35692     try {
35693       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35694     } catch (std::out_of_range& e) {
35695       {
35696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35697       };
35698     } catch (std::exception& e) {
35699       {
35700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35701       };
35702     } catch (Dali::DaliException e) {
35703       {
35704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35705       };
35706     } catch (...) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35709       };
35710     }
35711   }
35712
35713 }
35714
35715
35716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35717   void * jresult ;
35718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35719   Dali::Vector4 result;
35720
35721   arg1 = (Dali::Actor *)jarg1;
35722   {
35723     try {
35724       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35725     } catch (std::out_of_range& e) {
35726       {
35727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35728       };
35729     } catch (std::exception& e) {
35730       {
35731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35732       };
35733     } catch (Dali::DaliException e) {
35734       {
35735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35736       };
35737     } catch (...) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35740       };
35741     }
35742   }
35743
35744   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35745   return jresult;
35746 }
35747
35748
35749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35751   Dali::ColorMode arg2 ;
35752
35753   arg1 = (Dali::Actor *)jarg1;
35754   arg2 = (Dali::ColorMode)jarg2;
35755   {
35756     try {
35757       (arg1)->SetColorMode(arg2);
35758     } catch (std::out_of_range& e) {
35759       {
35760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35761       };
35762     } catch (std::exception& e) {
35763       {
35764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35765       };
35766     } catch (Dali::DaliException e) {
35767       {
35768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35769       };
35770     } catch (...) {
35771       {
35772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35773       };
35774     }
35775   }
35776
35777 }
35778
35779
35780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35781   int jresult ;
35782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35783   Dali::ColorMode result;
35784
35785   arg1 = (Dali::Actor *)jarg1;
35786   {
35787     try {
35788       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35789     } catch (std::out_of_range& e) {
35790       {
35791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35792       };
35793     } catch (std::exception& e) {
35794       {
35795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35796       };
35797     } catch (Dali::DaliException e) {
35798       {
35799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35800       };
35801     } catch (...) {
35802       {
35803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35804       };
35805     }
35806   }
35807
35808   jresult = (int)result;
35809   return jresult;
35810 }
35811
35812
35813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35814   void * jresult ;
35815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35816   Dali::Vector4 result;
35817
35818   arg1 = (Dali::Actor *)jarg1;
35819   {
35820     try {
35821       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35822     } catch (std::out_of_range& e) {
35823       {
35824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35825       };
35826     } catch (std::exception& e) {
35827       {
35828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35829       };
35830     } catch (Dali::DaliException e) {
35831       {
35832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35833       };
35834     } catch (...) {
35835       {
35836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35837       };
35838     }
35839   }
35840
35841   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35842   return jresult;
35843 }
35844
35845
35846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35847   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35848   Dali::DrawMode::Type arg2 ;
35849
35850   arg1 = (Dali::Actor *)jarg1;
35851   arg2 = (Dali::DrawMode::Type)jarg2;
35852   {
35853     try {
35854       (arg1)->SetDrawMode(arg2);
35855     } catch (std::out_of_range& e) {
35856       {
35857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35858       };
35859     } catch (std::exception& e) {
35860       {
35861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35862       };
35863     } catch (Dali::DaliException e) {
35864       {
35865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35866       };
35867     } catch (...) {
35868       {
35869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35870       };
35871     }
35872   }
35873
35874 }
35875
35876
35877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35878   int jresult ;
35879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35880   Dali::DrawMode::Type result;
35881
35882   arg1 = (Dali::Actor *)jarg1;
35883   {
35884     try {
35885       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35886     } catch (std::out_of_range& e) {
35887       {
35888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35889       };
35890     } catch (std::exception& e) {
35891       {
35892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35893       };
35894     } catch (Dali::DaliException e) {
35895       {
35896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35897       };
35898     } catch (...) {
35899       {
35900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35901       };
35902     }
35903   }
35904
35905   jresult = (int)result;
35906   return jresult;
35907 }
35908
35909
35910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35912   bool arg2 ;
35913
35914   arg1 = (Dali::Actor *)jarg1;
35915   arg2 = jarg2 ? true : false;
35916   {
35917     try {
35918       (arg1)->SetSensitive(arg2);
35919     } catch (std::out_of_range& e) {
35920       {
35921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35922       };
35923     } catch (std::exception& e) {
35924       {
35925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35926       };
35927     } catch (Dali::DaliException e) {
35928       {
35929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35930       };
35931     } catch (...) {
35932       {
35933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35934       };
35935     }
35936   }
35937
35938 }
35939
35940
35941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35942   unsigned int jresult ;
35943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35944   bool result;
35945
35946   arg1 = (Dali::Actor *)jarg1;
35947   {
35948     try {
35949       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35950     } catch (std::out_of_range& e) {
35951       {
35952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35953       };
35954     } catch (std::exception& e) {
35955       {
35956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35957       };
35958     } catch (Dali::DaliException e) {
35959       {
35960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35961       };
35962     } catch (...) {
35963       {
35964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35965       };
35966     }
35967   }
35968
35969   jresult = result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35975   unsigned int jresult ;
35976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35977   float *arg2 = 0 ;
35978   float *arg3 = 0 ;
35979   float arg4 ;
35980   float arg5 ;
35981   bool result;
35982
35983   arg1 = (Dali::Actor *)jarg1;
35984   arg2 = (float *)jarg2;
35985   arg3 = (float *)jarg3;
35986   arg4 = (float)jarg4;
35987   arg5 = (float)jarg5;
35988   {
35989     try {
35990       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35991     } catch (std::out_of_range& e) {
35992       {
35993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (std::exception& e) {
35996       {
35997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35998       };
35999     } catch (Dali::DaliException e) {
36000       {
36001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36002       };
36003     } catch (...) {
36004       {
36005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36006       };
36007     }
36008   }
36009
36010   jresult = result;
36011   return jresult;
36012 }
36013
36014
36015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36017   bool arg2 ;
36018
36019   arg1 = (Dali::Actor *)jarg1;
36020   arg2 = jarg2 ? true : false;
36021   {
36022     try {
36023       (arg1)->SetLeaveRequired(arg2);
36024     } catch (std::out_of_range& e) {
36025       {
36026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36027       };
36028     } catch (std::exception& e) {
36029       {
36030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36031       };
36032     } catch (Dali::DaliException e) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36035       };
36036     } catch (...) {
36037       {
36038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36039       };
36040     }
36041   }
36042
36043 }
36044
36045
36046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36047   unsigned int jresult ;
36048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36049   bool result;
36050
36051   arg1 = (Dali::Actor *)jarg1;
36052   {
36053     try {
36054       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36055     } catch (std::out_of_range& e) {
36056       {
36057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36058       };
36059     } catch (std::exception& e) {
36060       {
36061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36062       };
36063     } catch (Dali::DaliException e) {
36064       {
36065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36066       };
36067     } catch (...) {
36068       {
36069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36070       };
36071     }
36072   }
36073
36074   jresult = result;
36075   return jresult;
36076 }
36077
36078
36079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36081   bool arg2 ;
36082
36083   arg1 = (Dali::Actor *)jarg1;
36084   arg2 = jarg2 ? true : false;
36085   {
36086     try {
36087       (arg1)->SetKeyboardFocusable(arg2);
36088     } catch (std::out_of_range& e) {
36089       {
36090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36091       };
36092     } catch (std::exception& e) {
36093       {
36094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36095       };
36096     } catch (Dali::DaliException e) {
36097       {
36098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36099       };
36100     } catch (...) {
36101       {
36102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36103       };
36104     }
36105   }
36106
36107 }
36108
36109
36110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36111   unsigned int jresult ;
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool result;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   {
36117     try {
36118       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36119     } catch (std::out_of_range& e) {
36120       {
36121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (std::exception& e) {
36124       {
36125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36126       };
36127     } catch (Dali::DaliException e) {
36128       {
36129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36130       };
36131     } catch (...) {
36132       {
36133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36134       };
36135     }
36136   }
36137
36138   jresult = result;
36139   return jresult;
36140 }
36141
36142
36143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36145   Dali::ResizePolicy::Type arg2 ;
36146   Dali::Dimension::Type arg3 ;
36147
36148   arg1 = (Dali::Actor *)jarg1;
36149   arg2 = (Dali::ResizePolicy::Type)jarg2;
36150   arg3 = (Dali::Dimension::Type)jarg3;
36151   {
36152     try {
36153       (arg1)->SetResizePolicy(arg2,arg3);
36154     } catch (std::out_of_range& e) {
36155       {
36156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36157       };
36158     } catch (std::exception& e) {
36159       {
36160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36161       };
36162     } catch (Dali::DaliException e) {
36163       {
36164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36165       };
36166     } catch (...) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36169       };
36170     }
36171   }
36172
36173 }
36174
36175
36176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36177   int jresult ;
36178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36179   Dali::Dimension::Type arg2 ;
36180   Dali::ResizePolicy::Type result;
36181
36182   arg1 = (Dali::Actor *)jarg1;
36183   arg2 = (Dali::Dimension::Type)jarg2;
36184   {
36185     try {
36186       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36187     } catch (std::out_of_range& e) {
36188       {
36189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36190       };
36191     } catch (std::exception& e) {
36192       {
36193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36194       };
36195     } catch (Dali::DaliException e) {
36196       {
36197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36198       };
36199     } catch (...) {
36200       {
36201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36202       };
36203     }
36204   }
36205
36206   jresult = (int)result;
36207   return jresult;
36208 }
36209
36210
36211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36213   Dali::SizeScalePolicy::Type arg2 ;
36214
36215   arg1 = (Dali::Actor *)jarg1;
36216   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36217   {
36218     try {
36219       (arg1)->SetSizeScalePolicy(arg2);
36220     } catch (std::out_of_range& e) {
36221       {
36222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36223       };
36224     } catch (std::exception& e) {
36225       {
36226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36227       };
36228     } catch (Dali::DaliException e) {
36229       {
36230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36231       };
36232     } catch (...) {
36233       {
36234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36235       };
36236     }
36237   }
36238
36239 }
36240
36241
36242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36243   int jresult ;
36244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36245   Dali::SizeScalePolicy::Type result;
36246
36247   arg1 = (Dali::Actor *)jarg1;
36248   {
36249     try {
36250       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36251     } catch (std::out_of_range& e) {
36252       {
36253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36254       };
36255     } catch (std::exception& e) {
36256       {
36257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36258       };
36259     } catch (Dali::DaliException e) {
36260       {
36261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36262       };
36263     } catch (...) {
36264       {
36265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36266       };
36267     }
36268   }
36269
36270   jresult = (int)result;
36271   return jresult;
36272 }
36273
36274
36275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36276   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36277   Dali::Vector3 *arg2 = 0 ;
36278
36279   arg1 = (Dali::Actor *)jarg1;
36280   arg2 = (Dali::Vector3 *)jarg2;
36281   if (!arg2) {
36282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36283     return ;
36284   }
36285   {
36286     try {
36287       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36288     } catch (std::out_of_range& e) {
36289       {
36290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36291       };
36292     } catch (std::exception& e) {
36293       {
36294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36295       };
36296     } catch (Dali::DaliException e) {
36297       {
36298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36299       };
36300     } catch (...) {
36301       {
36302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36303       };
36304     }
36305   }
36306
36307 }
36308
36309
36310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36311   void * jresult ;
36312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36313   Dali::Vector3 result;
36314
36315   arg1 = (Dali::Actor *)jarg1;
36316   {
36317     try {
36318       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36319     } catch (std::out_of_range& e) {
36320       {
36321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36322       };
36323     } catch (std::exception& e) {
36324       {
36325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36326       };
36327     } catch (Dali::DaliException e) {
36328       {
36329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36330       };
36331     } catch (...) {
36332       {
36333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36334       };
36335     }
36336   }
36337
36338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36339   return jresult;
36340 }
36341
36342
36343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36344   float jresult ;
36345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36346   float arg2 ;
36347   float result;
36348
36349   arg1 = (Dali::Actor *)jarg1;
36350   arg2 = (float)jarg2;
36351   {
36352     try {
36353       result = (float)(arg1)->GetHeightForWidth(arg2);
36354     } catch (std::out_of_range& e) {
36355       {
36356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36357       };
36358     } catch (std::exception& e) {
36359       {
36360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (Dali::DaliException e) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372
36373   jresult = result;
36374   return jresult;
36375 }
36376
36377
36378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36379   float jresult ;
36380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36381   float arg2 ;
36382   float result;
36383
36384   arg1 = (Dali::Actor *)jarg1;
36385   arg2 = (float)jarg2;
36386   {
36387     try {
36388       result = (float)(arg1)->GetWidthForHeight(arg2);
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (Dali::DaliException e) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36400       };
36401     } catch (...) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36404       };
36405     }
36406   }
36407
36408   jresult = result;
36409   return jresult;
36410 }
36411
36412
36413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36414   float jresult ;
36415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36416   Dali::Dimension::Type arg2 ;
36417   float result;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   arg2 = (Dali::Dimension::Type)jarg2;
36421   {
36422     try {
36423       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36424     } catch (std::out_of_range& e) {
36425       {
36426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36427       };
36428     } catch (std::exception& e) {
36429       {
36430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36431       };
36432     } catch (Dali::DaliException e) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36435       };
36436     } catch (...) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36439       };
36440     }
36441   }
36442
36443   jresult = result;
36444   return jresult;
36445 }
36446
36447
36448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36450   Dali::Padding *arg2 = 0 ;
36451
36452   arg1 = (Dali::Actor *)jarg1;
36453   arg2 = (Dali::Padding *)jarg2;
36454   if (!arg2) {
36455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36456     return ;
36457   }
36458   {
36459     try {
36460       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36461     } catch (std::out_of_range& e) {
36462       {
36463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36464       };
36465     } catch (std::exception& e) {
36466       {
36467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36468       };
36469     } catch (Dali::DaliException e) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36472       };
36473     } catch (...) {
36474       {
36475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36476       };
36477     }
36478   }
36479
36480 }
36481
36482
36483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36485   Dali::Padding *arg2 = 0 ;
36486
36487   arg1 = (Dali::Actor *)jarg1;
36488   arg2 = (Dali::Padding *)jarg2;
36489   if (!arg2) {
36490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36491     return ;
36492   }
36493   {
36494     try {
36495       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36496     } catch (std::out_of_range& e) {
36497       {
36498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36499       };
36500     } catch (std::exception& e) {
36501       {
36502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36503       };
36504     } catch (Dali::DaliException e) {
36505       {
36506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36507       };
36508     } catch (...) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36511       };
36512     }
36513   }
36514
36515 }
36516
36517
36518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36520   Dali::Vector2 *arg2 = 0 ;
36521
36522   arg1 = (Dali::Actor *)jarg1;
36523   arg2 = (Dali::Vector2 *)jarg2;
36524   if (!arg2) {
36525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36526     return ;
36527   }
36528   {
36529     try {
36530       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36531     } catch (std::out_of_range& e) {
36532       {
36533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36534       };
36535     } catch (std::exception& e) {
36536       {
36537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36538       };
36539     } catch (Dali::DaliException e) {
36540       {
36541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36542       };
36543     } catch (...) {
36544       {
36545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36546       };
36547     }
36548   }
36549
36550 }
36551
36552
36553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36554   void * jresult ;
36555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36556   Dali::Vector2 result;
36557
36558   arg1 = (Dali::Actor *)jarg1;
36559   {
36560     try {
36561       result = (arg1)->GetMinimumSize();
36562     } catch (std::out_of_range& e) {
36563       {
36564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (std::exception& e) {
36567       {
36568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36569       };
36570     } catch (Dali::DaliException e) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36573       };
36574     } catch (...) {
36575       {
36576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36577       };
36578     }
36579   }
36580
36581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36582   return jresult;
36583 }
36584
36585
36586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36588   Dali::Vector2 *arg2 = 0 ;
36589
36590   arg1 = (Dali::Actor *)jarg1;
36591   arg2 = (Dali::Vector2 *)jarg2;
36592   if (!arg2) {
36593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36594     return ;
36595   }
36596   {
36597     try {
36598       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36599     } catch (std::out_of_range& e) {
36600       {
36601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36602       };
36603     } catch (std::exception& e) {
36604       {
36605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36606       };
36607     } catch (Dali::DaliException e) {
36608       {
36609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36610       };
36611     } catch (...) {
36612       {
36613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36614       };
36615     }
36616   }
36617
36618 }
36619
36620
36621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36622   void * jresult ;
36623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36624   Dali::Vector2 result;
36625
36626   arg1 = (Dali::Actor *)jarg1;
36627   {
36628     try {
36629       result = (arg1)->GetMaximumSize();
36630     } catch (std::out_of_range& e) {
36631       {
36632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36633       };
36634     } catch (std::exception& e) {
36635       {
36636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36637       };
36638     } catch (Dali::DaliException e) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36641       };
36642     } catch (...) {
36643       {
36644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36645       };
36646     }
36647   }
36648
36649   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36650   return jresult;
36651 }
36652
36653
36654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36655   int jresult ;
36656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36657   int result;
36658
36659   arg1 = (Dali::Actor *)jarg1;
36660   {
36661     try {
36662       result = (int)(arg1)->GetHierarchyDepth();
36663       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36664     } catch (std::out_of_range& e) {
36665       {
36666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36667       };
36668     } catch (std::exception& e) {
36669       {
36670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36671       };
36672     } catch (Dali::DaliException e) {
36673       {
36674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36675       };
36676     } catch (...) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36679       };
36680     }
36681   }
36682
36683   jresult = result;
36684   return jresult;
36685 }
36686
36687
36688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36689   unsigned int jresult ;
36690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36691   Dali::Renderer *arg2 = 0 ;
36692   unsigned int result;
36693
36694   arg1 = (Dali::Actor *)jarg1;
36695   arg2 = (Dali::Renderer *)jarg2;
36696   if (!arg2) {
36697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36698     return 0;
36699   }
36700   {
36701     try {
36702       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36703     } catch (std::out_of_range& e) {
36704       {
36705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36706       };
36707     } catch (std::exception& e) {
36708       {
36709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36710       };
36711     } catch (Dali::DaliException e) {
36712       {
36713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36714       };
36715     } catch (...) {
36716       {
36717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36718       };
36719     }
36720   }
36721
36722   jresult = result;
36723   return jresult;
36724 }
36725
36726
36727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36728   unsigned int jresult ;
36729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36730   unsigned int result;
36731
36732   arg1 = (Dali::Actor *)jarg1;
36733   {
36734     try {
36735       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36736     } catch (std::out_of_range& e) {
36737       {
36738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36739       };
36740     } catch (std::exception& e) {
36741       {
36742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36743       };
36744     } catch (Dali::DaliException e) {
36745       {
36746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36747       };
36748     } catch (...) {
36749       {
36750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36751       };
36752     }
36753   }
36754
36755   jresult = result;
36756   return jresult;
36757 }
36758
36759
36760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36761   void * jresult ;
36762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36763   unsigned int arg2 ;
36764   Dali::Renderer result;
36765
36766   arg1 = (Dali::Actor *)jarg1;
36767   arg2 = (unsigned int)jarg2;
36768   {
36769     try {
36770       result = (arg1)->GetRendererAt(arg2);
36771     } catch (std::out_of_range& e) {
36772       {
36773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36774       };
36775     } catch (std::exception& e) {
36776       {
36777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36778       };
36779     } catch (Dali::DaliException e) {
36780       {
36781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36782       };
36783     } catch (...) {
36784       {
36785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36786       };
36787     }
36788   }
36789
36790   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36791   return jresult;
36792 }
36793
36794
36795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36797   Dali::Renderer *arg2 = 0 ;
36798
36799   arg1 = (Dali::Actor *)jarg1;
36800   arg2 = (Dali::Renderer *)jarg2;
36801   if (!arg2) {
36802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36803     return ;
36804   }
36805   {
36806     try {
36807       (arg1)->RemoveRenderer(*arg2);
36808     } catch (std::out_of_range& e) {
36809       {
36810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36811       };
36812     } catch (std::exception& e) {
36813       {
36814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36815       };
36816     } catch (Dali::DaliException e) {
36817       {
36818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36819       };
36820     } catch (...) {
36821       {
36822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36823       };
36824     }
36825   }
36826
36827 }
36828
36829
36830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36832   unsigned int arg2 ;
36833
36834   arg1 = (Dali::Actor *)jarg1;
36835   arg2 = (unsigned int)jarg2;
36836   {
36837     try {
36838       (arg1)->RemoveRenderer(arg2);
36839     } catch (std::out_of_range& e) {
36840       {
36841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36842       };
36843     } catch (std::exception& e) {
36844       {
36845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36846       };
36847     } catch (Dali::DaliException e) {
36848       {
36849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36850       };
36851     } catch (...) {
36852       {
36853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36854       };
36855     }
36856   }
36857
36858 }
36859
36860
36861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36862   void * jresult ;
36863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36864   Dali::Actor::TouchSignalType *result = 0 ;
36865
36866   arg1 = (Dali::Actor *)jarg1;
36867   {
36868     try {
36869       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36870     } catch (std::out_of_range& e) {
36871       {
36872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36873       };
36874     } catch (std::exception& e) {
36875       {
36876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36877       };
36878     } catch (Dali::DaliException e) {
36879       {
36880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36881       };
36882     } catch (...) {
36883       {
36884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36885       };
36886     }
36887   }
36888
36889   jresult = (void *)result;
36890   return jresult;
36891 }
36892
36893
36894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36895   void * jresult ;
36896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36897   Dali::Actor::TouchDataSignalType *result = 0 ;
36898
36899   arg1 = (Dali::Actor *)jarg1;
36900   {
36901     try {
36902       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36903     } catch (std::out_of_range& e) {
36904       {
36905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36906       };
36907     } catch (std::exception& e) {
36908       {
36909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36910       };
36911     } catch (Dali::DaliException e) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36914       };
36915     } catch (...) {
36916       {
36917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36918       };
36919     }
36920   }
36921
36922   jresult = (void *)result;
36923   return jresult;
36924 }
36925
36926
36927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36928   void * jresult ;
36929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36930   Dali::Actor::HoverSignalType *result = 0 ;
36931
36932   arg1 = (Dali::Actor *)jarg1;
36933   {
36934     try {
36935       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
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_WheelEventSignal(void * jarg1) {
36961   void * jresult ;
36962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36963   Dali::Actor::WheelEventSignalType *result = 0 ;
36964
36965   arg1 = (Dali::Actor *)jarg1;
36966   {
36967     try {
36968       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
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_OnStageSignal(void * jarg1) {
36994   void * jresult ;
36995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36996   Dali::Actor::OnStageSignalType *result = 0 ;
36997
36998   arg1 = (Dali::Actor *)jarg1;
36999   {
37000     try {
37001       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
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_OffStageSignal(void * jarg1) {
37027   void * jresult ;
37028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37029   Dali::Actor::OffStageSignalType *result = 0 ;
37030
37031   arg1 = (Dali::Actor *)jarg1;
37032   {
37033     try {
37034       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
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_OnRelayoutSignal(void * jarg1) {
37060   void * jresult ;
37061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37062   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37063
37064   arg1 = (Dali::Actor *)jarg1;
37065   {
37066     try {
37067       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
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_UnparentAndReset(void * jarg1) {
37093   Dali::Actor *arg1 = 0 ;
37094
37095   arg1 = (Dali::Actor *)jarg1;
37096   if (!arg1) {
37097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37098     return ;
37099   }
37100   {
37101     try {
37102       Dali::UnparentAndReset(*arg1);
37103     } catch (std::out_of_range& e) {
37104       {
37105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37106       };
37107     } catch (std::exception& e) {
37108       {
37109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37110       };
37111     } catch (Dali::DaliException e) {
37112       {
37113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37114       };
37115     } catch (...) {
37116       {
37117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37118       };
37119     }
37120   }
37121
37122 }
37123
37124
37125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37126   int jresult ;
37127   int result;
37128
37129   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37130   jresult = (int)result;
37131   return jresult;
37132 }
37133
37134
37135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37136   int jresult ;
37137   int result;
37138
37139   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37140   jresult = (int)result;
37141   return jresult;
37142 }
37143
37144
37145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37146   int jresult ;
37147   int result;
37148
37149   result = (int)Dali::Layer::Property::BEHAVIOR;
37150   jresult = (int)result;
37151   return jresult;
37152 }
37153
37154
37155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37156   void * jresult ;
37157   Dali::Layer::Property *result = 0 ;
37158
37159   {
37160     try {
37161       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37162     } catch (std::out_of_range& e) {
37163       {
37164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37165       };
37166     } catch (std::exception& e) {
37167       {
37168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37169       };
37170     } catch (Dali::DaliException e) {
37171       {
37172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37173       };
37174     } catch (...) {
37175       {
37176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37177       };
37178     }
37179   }
37180
37181   jresult = (void *)result;
37182   return jresult;
37183 }
37184
37185
37186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37187   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37188
37189   arg1 = (Dali::Layer::Property *)jarg1;
37190   {
37191     try {
37192       delete arg1;
37193     } catch (std::out_of_range& e) {
37194       {
37195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37196       };
37197     } catch (std::exception& e) {
37198       {
37199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37200       };
37201     } catch (Dali::DaliException e) {
37202       {
37203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37204       };
37205     } catch (...) {
37206       {
37207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37208       };
37209     }
37210   }
37211
37212 }
37213
37214
37215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37216   void * jresult ;
37217   Dali::Layer *result = 0 ;
37218
37219   {
37220     try {
37221       result = (Dali::Layer *)new Dali::Layer();
37222     } catch (std::out_of_range& e) {
37223       {
37224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37225       };
37226     } catch (std::exception& e) {
37227       {
37228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37229       };
37230     } catch (Dali::DaliException e) {
37231       {
37232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37233       };
37234     } catch (...) {
37235       {
37236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37237       };
37238     }
37239   }
37240
37241   jresult = (void *)result;
37242   return jresult;
37243 }
37244
37245
37246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37247   void * jresult ;
37248   Dali::Layer result;
37249
37250   {
37251     try {
37252       result = Dali::Layer::New();
37253     } catch (std::out_of_range& e) {
37254       {
37255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37256       };
37257     } catch (std::exception& e) {
37258       {
37259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37260       };
37261     } catch (Dali::DaliException e) {
37262       {
37263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37264       };
37265     } catch (...) {
37266       {
37267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37268       };
37269     }
37270   }
37271
37272   jresult = new Dali::Layer((const Dali::Layer &)result);
37273   return jresult;
37274 }
37275
37276
37277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37278   void * jresult ;
37279   Dali::BaseHandle arg1 ;
37280   Dali::BaseHandle *argp1 ;
37281   Dali::Layer result;
37282
37283   argp1 = (Dali::BaseHandle *)jarg1;
37284   if (!argp1) {
37285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37286     return 0;
37287   }
37288   arg1 = *argp1;
37289   {
37290     try {
37291       result = Dali::Layer::DownCast(arg1);
37292     } catch (std::out_of_range& e) {
37293       {
37294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37295       };
37296     } catch (std::exception& e) {
37297       {
37298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37299       };
37300     } catch (Dali::DaliException e) {
37301       {
37302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37303       };
37304     } catch (...) {
37305       {
37306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37307       };
37308     }
37309   }
37310
37311   jresult = new Dali::Layer((const Dali::Layer &)result);
37312   return jresult;
37313 }
37314
37315
37316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37317   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37318
37319   arg1 = (Dali::Layer *)jarg1;
37320   {
37321     try {
37322       delete arg1;
37323     } catch (std::out_of_range& e) {
37324       {
37325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37326       };
37327     } catch (std::exception& e) {
37328       {
37329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37330       };
37331     } catch (Dali::DaliException e) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37334       };
37335     } catch (...) {
37336       {
37337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37338       };
37339     }
37340   }
37341
37342 }
37343
37344
37345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37346   void * jresult ;
37347   Dali::Layer *arg1 = 0 ;
37348   Dali::Layer *result = 0 ;
37349
37350   arg1 = (Dali::Layer *)jarg1;
37351   if (!arg1) {
37352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37353     return 0;
37354   }
37355   {
37356     try {
37357       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*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 = (void *)result;
37378   return jresult;
37379 }
37380
37381
37382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37383   void * jresult ;
37384   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37385   Dali::Layer *arg2 = 0 ;
37386   Dali::Layer *result = 0 ;
37387
37388   arg1 = (Dali::Layer *)jarg1;
37389   arg2 = (Dali::Layer *)jarg2;
37390   if (!arg2) {
37391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37392     return 0;
37393   }
37394   {
37395     try {
37396       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37397     } catch (std::out_of_range& e) {
37398       {
37399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37400       };
37401     } catch (std::exception& e) {
37402       {
37403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37404       };
37405     } catch (Dali::DaliException e) {
37406       {
37407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37408       };
37409     } catch (...) {
37410       {
37411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37412       };
37413     }
37414   }
37415
37416   jresult = (void *)result;
37417   return jresult;
37418 }
37419
37420
37421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37422   unsigned int jresult ;
37423   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37424   unsigned int result;
37425
37426   arg1 = (Dali::Layer *)jarg1;
37427   {
37428     try {
37429       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37430     } catch (std::out_of_range& e) {
37431       {
37432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37433       };
37434     } catch (std::exception& e) {
37435       {
37436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37437       };
37438     } catch (Dali::DaliException e) {
37439       {
37440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37441       };
37442     } catch (...) {
37443       {
37444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37445       };
37446     }
37447   }
37448
37449   jresult = result;
37450   return jresult;
37451 }
37452
37453
37454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37455   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37456
37457   arg1 = (Dali::Layer *)jarg1;
37458   {
37459     try {
37460       (arg1)->Raise();
37461     } catch (std::out_of_range& e) {
37462       {
37463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37464       };
37465     } catch (std::exception& e) {
37466       {
37467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37468       };
37469     } catch (Dali::DaliException e) {
37470       {
37471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37472       };
37473     } catch (...) {
37474       {
37475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37476       };
37477     }
37478   }
37479
37480 }
37481
37482
37483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37484   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37485
37486   arg1 = (Dali::Layer *)jarg1;
37487   {
37488     try {
37489       (arg1)->Lower();
37490     } catch (std::out_of_range& e) {
37491       {
37492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37493       };
37494     } catch (std::exception& e) {
37495       {
37496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37497       };
37498     } catch (Dali::DaliException e) {
37499       {
37500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37501       };
37502     } catch (...) {
37503       {
37504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37505       };
37506     }
37507   }
37508
37509 }
37510
37511
37512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37513   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37514   Dali::Layer arg2 ;
37515   Dali::Layer *argp2 ;
37516
37517   arg1 = (Dali::Layer *)jarg1;
37518   argp2 = (Dali::Layer *)jarg2;
37519   if (!argp2) {
37520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37521     return ;
37522   }
37523   arg2 = *argp2;
37524   {
37525     try {
37526       (arg1)->RaiseAbove(arg2);
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_LowerBelow(void * jarg1, void * jarg2) {
37550   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37551   Dali::Layer arg2 ;
37552   Dali::Layer *argp2 ;
37553
37554   arg1 = (Dali::Layer *)jarg1;
37555   argp2 = (Dali::Layer *)jarg2;
37556   if (!argp2) {
37557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37558     return ;
37559   }
37560   arg2 = *argp2;
37561   {
37562     try {
37563       (arg1)->LowerBelow(arg2);
37564     } catch (std::out_of_range& e) {
37565       {
37566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37567       };
37568     } catch (std::exception& e) {
37569       {
37570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37571       };
37572     } catch (Dali::DaliException e) {
37573       {
37574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37575       };
37576     } catch (...) {
37577       {
37578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37579       };
37580     }
37581   }
37582
37583 }
37584
37585
37586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37587   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37588
37589   arg1 = (Dali::Layer *)jarg1;
37590   {
37591     try {
37592       (arg1)->RaiseToTop();
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_LowerToBottom(void * jarg1) {
37616   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37617
37618   arg1 = (Dali::Layer *)jarg1;
37619   {
37620     try {
37621       (arg1)->LowerToBottom();
37622     } catch (std::out_of_range& e) {
37623       {
37624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37625       };
37626     } catch (std::exception& e) {
37627       {
37628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37629       };
37630     } catch (Dali::DaliException e) {
37631       {
37632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37633       };
37634     } catch (...) {
37635       {
37636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37637       };
37638     }
37639   }
37640
37641 }
37642
37643
37644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37645   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37646   Dali::Layer arg2 ;
37647   Dali::Layer *argp2 ;
37648
37649   arg1 = (Dali::Layer *)jarg1;
37650   argp2 = (Dali::Layer *)jarg2;
37651   if (!argp2) {
37652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37653     return ;
37654   }
37655   arg2 = *argp2;
37656   {
37657     try {
37658       (arg1)->MoveAbove(arg2);
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_MoveBelow(void * jarg1, void * jarg2) {
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683   Dali::Layer arg2 ;
37684   Dali::Layer *argp2 ;
37685
37686   arg1 = (Dali::Layer *)jarg1;
37687   argp2 = (Dali::Layer *)jarg2;
37688   if (!argp2) {
37689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37690     return ;
37691   }
37692   arg2 = *argp2;
37693   {
37694     try {
37695       (arg1)->MoveBelow(arg2);
37696     } catch (std::out_of_range& e) {
37697       {
37698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (std::exception& e) {
37701       {
37702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37703       };
37704     } catch (Dali::DaliException e) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37707       };
37708     } catch (...) {
37709       {
37710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37711       };
37712     }
37713   }
37714
37715 }
37716
37717
37718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37720   Dali::Layer::Behavior arg2 ;
37721
37722   arg1 = (Dali::Layer *)jarg1;
37723   arg2 = (Dali::Layer::Behavior)jarg2;
37724   {
37725     try {
37726       (arg1)->SetBehavior(arg2);
37727     } catch (std::out_of_range& e) {
37728       {
37729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37730       };
37731     } catch (std::exception& e) {
37732       {
37733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37734       };
37735     } catch (Dali::DaliException e) {
37736       {
37737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37738       };
37739     } catch (...) {
37740       {
37741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37742       };
37743     }
37744   }
37745
37746 }
37747
37748
37749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37750   int jresult ;
37751   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37752   Dali::Layer::Behavior result;
37753
37754   arg1 = (Dali::Layer *)jarg1;
37755   {
37756     try {
37757       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37758     } catch (std::out_of_range& e) {
37759       {
37760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37761       };
37762     } catch (std::exception& e) {
37763       {
37764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37765       };
37766     } catch (Dali::DaliException e) {
37767       {
37768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37769       };
37770     } catch (...) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37773       };
37774     }
37775   }
37776
37777   jresult = (int)result;
37778   return jresult;
37779 }
37780
37781
37782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37784   bool arg2 ;
37785
37786   arg1 = (Dali::Layer *)jarg1;
37787   arg2 = jarg2 ? true : false;
37788   {
37789     try {
37790       (arg1)->SetClipping(arg2);
37791     } catch (std::out_of_range& e) {
37792       {
37793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (std::exception& e) {
37796       {
37797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37798       };
37799     } catch (Dali::DaliException e) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37802       };
37803     } catch (...) {
37804       {
37805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37806       };
37807     }
37808   }
37809
37810 }
37811
37812
37813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37814   unsigned int jresult ;
37815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37816   bool result;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   {
37820     try {
37821       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37822     } catch (std::out_of_range& e) {
37823       {
37824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37825       };
37826     } catch (std::exception& e) {
37827       {
37828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37829       };
37830     } catch (Dali::DaliException e) {
37831       {
37832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37833       };
37834     } catch (...) {
37835       {
37836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37837       };
37838     }
37839   }
37840
37841   jresult = result;
37842   return jresult;
37843 }
37844
37845
37846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37848   int arg2 ;
37849   int arg3 ;
37850   int arg4 ;
37851   int arg5 ;
37852
37853   arg1 = (Dali::Layer *)jarg1;
37854   arg2 = (int)jarg2;
37855   arg3 = (int)jarg3;
37856   arg4 = (int)jarg4;
37857   arg5 = (int)jarg5;
37858   {
37859     try {
37860       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37861     } catch (std::out_of_range& e) {
37862       {
37863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37864       };
37865     } catch (std::exception& e) {
37866       {
37867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37868       };
37869     } catch (Dali::DaliException e) {
37870       {
37871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37872       };
37873     } catch (...) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37876       };
37877     }
37878   }
37879
37880 }
37881
37882
37883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37884   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37885   Dali::ClippingBox arg2 ;
37886   Dali::ClippingBox *argp2 ;
37887
37888   arg1 = (Dali::Layer *)jarg1;
37889   argp2 = (Dali::ClippingBox *)jarg2;
37890   if (!argp2) {
37891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37892     return ;
37893   }
37894   arg2 = *argp2;
37895   {
37896     try {
37897       (arg1)->SetClippingBox(arg2);
37898     } catch (std::out_of_range& e) {
37899       {
37900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37901       };
37902     } catch (std::exception& e) {
37903       {
37904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37905       };
37906     } catch (Dali::DaliException e) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37909       };
37910     } catch (...) {
37911       {
37912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37913       };
37914     }
37915   }
37916
37917 }
37918
37919
37920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37921   void * jresult ;
37922   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37923   Dali::ClippingBox result;
37924
37925   arg1 = (Dali::Layer *)jarg1;
37926   {
37927     try {
37928       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37929     } catch (std::out_of_range& e) {
37930       {
37931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (std::exception& e) {
37934       {
37935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37936       };
37937     } catch (Dali::DaliException e) {
37938       {
37939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37940       };
37941     } catch (...) {
37942       {
37943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37944       };
37945     }
37946   }
37947
37948   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37949   return jresult;
37950 }
37951
37952
37953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37954   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37955   bool arg2 ;
37956
37957   arg1 = (Dali::Layer *)jarg1;
37958   arg2 = jarg2 ? true : false;
37959   {
37960     try {
37961       (arg1)->SetDepthTestDisabled(arg2);
37962     } catch (std::out_of_range& e) {
37963       {
37964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37965       };
37966     } catch (std::exception& e) {
37967       {
37968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37969       };
37970     } catch (Dali::DaliException e) {
37971       {
37972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37973       };
37974     } catch (...) {
37975       {
37976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37977       };
37978     }
37979   }
37980
37981 }
37982
37983
37984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37985   unsigned int jresult ;
37986   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37987   bool result;
37988
37989   arg1 = (Dali::Layer *)jarg1;
37990   {
37991     try {
37992       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37993     } catch (std::out_of_range& e) {
37994       {
37995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37996       };
37997     } catch (std::exception& e) {
37998       {
37999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38000       };
38001     } catch (Dali::DaliException e) {
38002       {
38003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38004       };
38005     } catch (...) {
38006       {
38007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38008       };
38009     }
38010   }
38011
38012   jresult = result;
38013   return jresult;
38014 }
38015
38016
38017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38018   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38019   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38020
38021   arg1 = (Dali::Layer *)jarg1;
38022   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38023   {
38024     try {
38025       (arg1)->SetSortFunction(arg2);
38026     } catch (std::out_of_range& e) {
38027       {
38028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38029       };
38030     } catch (std::exception& e) {
38031       {
38032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (Dali::DaliException e) {
38035       {
38036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38037       };
38038     } catch (...) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38041       };
38042     }
38043   }
38044
38045 }
38046
38047
38048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38049   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38050   bool arg2 ;
38051
38052   arg1 = (Dali::Layer *)jarg1;
38053   arg2 = jarg2 ? true : false;
38054   {
38055     try {
38056       (arg1)->SetTouchConsumed(arg2);
38057     } catch (std::out_of_range& e) {
38058       {
38059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38060       };
38061     } catch (std::exception& e) {
38062       {
38063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38064       };
38065     } catch (Dali::DaliException e) {
38066       {
38067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38068       };
38069     } catch (...) {
38070       {
38071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38072       };
38073     }
38074   }
38075
38076 }
38077
38078
38079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38080   unsigned int jresult ;
38081   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38082   bool result;
38083
38084   arg1 = (Dali::Layer *)jarg1;
38085   {
38086     try {
38087       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38088     } catch (std::out_of_range& e) {
38089       {
38090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38091       };
38092     } catch (std::exception& e) {
38093       {
38094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38095       };
38096     } catch (Dali::DaliException e) {
38097       {
38098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38099       };
38100     } catch (...) {
38101       {
38102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38103       };
38104     }
38105   }
38106
38107   jresult = result;
38108   return jresult;
38109 }
38110
38111
38112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38113   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38114   bool arg2 ;
38115
38116   arg1 = (Dali::Layer *)jarg1;
38117   arg2 = jarg2 ? true : false;
38118   {
38119     try {
38120       (arg1)->SetHoverConsumed(arg2);
38121     } catch (std::out_of_range& e) {
38122       {
38123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38124       };
38125     } catch (std::exception& e) {
38126       {
38127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38128       };
38129     } catch (Dali::DaliException e) {
38130       {
38131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38132       };
38133     } catch (...) {
38134       {
38135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38136       };
38137     }
38138   }
38139
38140 }
38141
38142
38143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38144   unsigned int jresult ;
38145   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38146   bool result;
38147
38148   arg1 = (Dali::Layer *)jarg1;
38149   {
38150     try {
38151       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38152     } catch (std::out_of_range& e) {
38153       {
38154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38155       };
38156     } catch (std::exception& e) {
38157       {
38158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38159       };
38160     } catch (Dali::DaliException e) {
38161       {
38162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38163       };
38164     } catch (...) {
38165       {
38166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38167       };
38168     }
38169   }
38170
38171   jresult = result;
38172   return jresult;
38173 }
38174
38175
38176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38177   void * jresult ;
38178   Dali::Vector4 *result = 0 ;
38179
38180   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38181   jresult = (void *)result;
38182   return jresult;
38183 }
38184
38185
38186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38187   void * jresult ;
38188   Dali::Vector4 *result = 0 ;
38189
38190   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38191   jresult = (void *)result;
38192   return jresult;
38193 }
38194
38195
38196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38197   void * jresult ;
38198   Dali::Stage *result = 0 ;
38199
38200   {
38201     try {
38202       result = (Dali::Stage *)new Dali::Stage();
38203     } catch (std::out_of_range& e) {
38204       {
38205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38206       };
38207     } catch (std::exception& e) {
38208       {
38209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38210       };
38211     } catch (Dali::DaliException e) {
38212       {
38213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38214       };
38215     } catch (...) {
38216       {
38217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38218       };
38219     }
38220   }
38221
38222   jresult = (void *)result;
38223   return jresult;
38224 }
38225
38226
38227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38228   void * jresult ;
38229   Dali::Stage result;
38230
38231   {
38232     try {
38233       result = Dali::Stage::GetCurrent();
38234     } catch (std::out_of_range& e) {
38235       {
38236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38237       };
38238     } catch (std::exception& e) {
38239       {
38240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38241       };
38242     } catch (Dali::DaliException e) {
38243       {
38244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38245       };
38246     } catch (...) {
38247       {
38248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38249       };
38250     }
38251   }
38252
38253   jresult = new Dali::Stage((const Dali::Stage &)result);
38254   return jresult;
38255 }
38256
38257
38258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38259   unsigned int jresult ;
38260   bool result;
38261
38262   {
38263     try {
38264       result = (bool)Dali::Stage::IsInstalled();
38265     } catch (std::out_of_range& e) {
38266       {
38267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38268       };
38269     } catch (std::exception& e) {
38270       {
38271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38272       };
38273     } catch (Dali::DaliException e) {
38274       {
38275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38276       };
38277     } catch (...) {
38278       {
38279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38280       };
38281     }
38282   }
38283
38284   jresult = result;
38285   return jresult;
38286 }
38287
38288
38289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38290   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38291
38292   arg1 = (Dali::Stage *)jarg1;
38293   {
38294     try {
38295       delete arg1;
38296     } catch (std::out_of_range& e) {
38297       {
38298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38299       };
38300     } catch (std::exception& e) {
38301       {
38302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38303       };
38304     } catch (Dali::DaliException e) {
38305       {
38306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38307       };
38308     } catch (...) {
38309       {
38310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38311       };
38312     }
38313   }
38314
38315 }
38316
38317
38318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38319   void * jresult ;
38320   Dali::Stage *arg1 = 0 ;
38321   Dali::Stage *result = 0 ;
38322
38323   arg1 = (Dali::Stage *)jarg1;
38324   if (!arg1) {
38325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38326     return 0;
38327   }
38328   {
38329     try {
38330       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
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 = (void *)result;
38351   return jresult;
38352 }
38353
38354
38355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38356   void * jresult ;
38357   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38358   Dali::Stage *arg2 = 0 ;
38359   Dali::Stage *result = 0 ;
38360
38361   arg1 = (Dali::Stage *)jarg1;
38362   arg2 = (Dali::Stage *)jarg2;
38363   if (!arg2) {
38364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38365     return 0;
38366   }
38367   {
38368     try {
38369       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38370     } catch (std::out_of_range& e) {
38371       {
38372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38373       };
38374     } catch (std::exception& e) {
38375       {
38376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38377       };
38378     } catch (Dali::DaliException e) {
38379       {
38380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38381       };
38382     } catch (...) {
38383       {
38384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38385       };
38386     }
38387   }
38388
38389   jresult = (void *)result;
38390   return jresult;
38391 }
38392
38393
38394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38395   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38396   Dali::Actor *arg2 = 0 ;
38397
38398   arg1 = (Dali::Stage *)jarg1;
38399   arg2 = (Dali::Actor *)jarg2;
38400   if (!arg2) {
38401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38402     return ;
38403   }
38404   {
38405     try {
38406       (arg1)->Add(*arg2);
38407     } catch (std::out_of_range& e) {
38408       {
38409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38410       };
38411     } catch (std::exception& e) {
38412       {
38413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38414       };
38415     } catch (Dali::DaliException e) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38418       };
38419     } catch (...) {
38420       {
38421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38422       };
38423     }
38424   }
38425
38426 }
38427
38428
38429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38430   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38431   Dali::Actor *arg2 = 0 ;
38432
38433   arg1 = (Dali::Stage *)jarg1;
38434   arg2 = (Dali::Actor *)jarg2;
38435   if (!arg2) {
38436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38437     return ;
38438   }
38439   {
38440     try {
38441       (arg1)->Remove(*arg2);
38442     } catch (std::out_of_range& e) {
38443       {
38444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38445       };
38446     } catch (std::exception& e) {
38447       {
38448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38449       };
38450     } catch (Dali::DaliException e) {
38451       {
38452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38453       };
38454     } catch (...) {
38455       {
38456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38457       };
38458     }
38459   }
38460
38461 }
38462
38463
38464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38465   void * jresult ;
38466   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38467   Dali::Vector2 result;
38468
38469   arg1 = (Dali::Stage *)jarg1;
38470   {
38471     try {
38472       result = ((Dali::Stage const *)arg1)->GetSize();
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38480       };
38481     } catch (Dali::DaliException e) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38484       };
38485     } catch (...) {
38486       {
38487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38488       };
38489     }
38490   }
38491
38492   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38493   return jresult;
38494 }
38495
38496
38497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38498   void * jresult ;
38499   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38500   Dali::RenderTaskList result;
38501
38502   arg1 = (Dali::Stage *)jarg1;
38503   {
38504     try {
38505       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38506     } catch (std::out_of_range& e) {
38507       {
38508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38509       };
38510     } catch (std::exception& e) {
38511       {
38512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38513       };
38514     } catch (Dali::DaliException e) {
38515       {
38516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38517       };
38518     } catch (...) {
38519       {
38520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38521       };
38522     }
38523   }
38524
38525   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38526   return jresult;
38527 }
38528
38529
38530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38531   unsigned int jresult ;
38532   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38533   unsigned int result;
38534
38535   arg1 = (Dali::Stage *)jarg1;
38536   {
38537     try {
38538       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
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 = result;
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38564   void * jresult ;
38565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38566   unsigned int arg2 ;
38567   Dali::Layer result;
38568
38569   arg1 = (Dali::Stage *)jarg1;
38570   arg2 = (unsigned int)jarg2;
38571   {
38572     try {
38573       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38574     } catch (std::out_of_range& e) {
38575       {
38576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38577       };
38578     } catch (std::exception& e) {
38579       {
38580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38581       };
38582     } catch (Dali::DaliException e) {
38583       {
38584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38585       };
38586     } catch (...) {
38587       {
38588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38589       };
38590     }
38591   }
38592
38593   jresult = new Dali::Layer((const Dali::Layer &)result);
38594   return jresult;
38595 }
38596
38597
38598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38599   void * jresult ;
38600   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38601   Dali::Layer result;
38602
38603   arg1 = (Dali::Stage *)jarg1;
38604   {
38605     try {
38606       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38607     } catch (std::out_of_range& e) {
38608       {
38609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38610       };
38611     } catch (std::exception& e) {
38612       {
38613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38614       };
38615     } catch (Dali::DaliException e) {
38616       {
38617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38618       };
38619     } catch (...) {
38620       {
38621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38622       };
38623     }
38624   }
38625
38626   jresult = new Dali::Layer((const Dali::Layer &)result);
38627   return jresult;
38628 }
38629
38630
38631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38632   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38633   Dali::Vector4 arg2 ;
38634   Dali::Vector4 *argp2 ;
38635
38636   arg1 = (Dali::Stage *)jarg1;
38637   argp2 = (Dali::Vector4 *)jarg2;
38638   if (!argp2) {
38639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38640     return ;
38641   }
38642   arg2 = *argp2;
38643   {
38644     try {
38645       (arg1)->SetBackgroundColor(arg2);
38646     } catch (std::out_of_range& e) {
38647       {
38648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38649       };
38650     } catch (std::exception& e) {
38651       {
38652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38653       };
38654     } catch (Dali::DaliException e) {
38655       {
38656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38657       };
38658     } catch (...) {
38659       {
38660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38661       };
38662     }
38663   }
38664
38665 }
38666
38667
38668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38669   void * jresult ;
38670   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38671   Dali::Vector4 result;
38672
38673   arg1 = (Dali::Stage *)jarg1;
38674   {
38675     try {
38676       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38677     } catch (std::out_of_range& e) {
38678       {
38679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38680       };
38681     } catch (std::exception& e) {
38682       {
38683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38684       };
38685     } catch (Dali::DaliException e) {
38686       {
38687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38688       };
38689     } catch (...) {
38690       {
38691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38692       };
38693     }
38694   }
38695
38696   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38697   return jresult;
38698 }
38699
38700
38701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38702   void * jresult ;
38703   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38704   Dali::Vector2 result;
38705
38706   arg1 = (Dali::Stage *)jarg1;
38707   {
38708     try {
38709       result = ((Dali::Stage const *)arg1)->GetDpi();
38710     } catch (std::out_of_range& e) {
38711       {
38712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38713       };
38714     } catch (std::exception& e) {
38715       {
38716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38717       };
38718     } catch (Dali::DaliException e) {
38719       {
38720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38721       };
38722     } catch (...) {
38723       {
38724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38725       };
38726     }
38727   }
38728
38729   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38730   return jresult;
38731 }
38732
38733
38734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38735   void * jresult ;
38736   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38737   Dali::ObjectRegistry result;
38738
38739   arg1 = (Dali::Stage *)jarg1;
38740   {
38741     try {
38742       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
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::ObjectRegistry((const Dali::ObjectRegistry &)result);
38763   return jresult;
38764 }
38765
38766
38767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38768   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38769   float arg2 ;
38770
38771   arg1 = (Dali::Stage *)jarg1;
38772   arg2 = (float)jarg2;
38773   {
38774     try {
38775       (arg1)->KeepRendering(arg2);
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38783       };
38784     } catch (Dali::DaliException e) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38787       };
38788     } catch (...) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38791       };
38792     }
38793   }
38794
38795 }
38796
38797
38798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38799   void * jresult ;
38800   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38801   Dali::Stage::KeyEventSignalType *result = 0 ;
38802
38803   arg1 = (Dali::Stage *)jarg1;
38804   {
38805     try {
38806       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38807     } catch (std::out_of_range& e) {
38808       {
38809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38810       };
38811     } catch (std::exception& e) {
38812       {
38813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38814       };
38815     } catch (Dali::DaliException e) {
38816       {
38817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38818       };
38819     } catch (...) {
38820       {
38821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38822       };
38823     }
38824   }
38825
38826   jresult = (void *)result;
38827   return jresult;
38828 }
38829
38830
38831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38832   void * jresult ;
38833   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38834   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38835
38836   arg1 = (Dali::Stage *)jarg1;
38837   {
38838     try {
38839       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38840     } catch (std::out_of_range& e) {
38841       {
38842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38843       };
38844     } catch (std::exception& e) {
38845       {
38846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38847       };
38848     } catch (Dali::DaliException e) {
38849       {
38850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38851       };
38852     } catch (...) {
38853       {
38854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38855       };
38856     }
38857   }
38858
38859   jresult = (void *)result;
38860   return jresult;
38861 }
38862
38863
38864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38865   void * jresult ;
38866   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38867   Dali::Stage::TouchSignalType *result = 0 ;
38868
38869   arg1 = (Dali::Stage *)jarg1;
38870   {
38871     try {
38872       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
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_WheelEventSignal(void * jarg1) {
38898   void * jresult ;
38899   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38900   Dali::Stage::WheelEventSignalType *result = 0 ;
38901
38902   arg1 = (Dali::Stage *)jarg1;
38903   {
38904     try {
38905       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
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_ContextLostSignal(void * jarg1) {
38931   void * jresult ;
38932   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38933   Dali::Stage::ContextStatusSignal *result = 0 ;
38934
38935   arg1 = (Dali::Stage *)jarg1;
38936   {
38937     try {
38938       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
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_ContextRegainedSignal(void * jarg1) {
38964   void * jresult ;
38965   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38966   Dali::Stage::ContextStatusSignal *result = 0 ;
38967
38968   arg1 = (Dali::Stage *)jarg1;
38969   {
38970     try {
38971       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
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_SceneCreatedSignal(void * jarg1) {
38997   void * jresult ;
38998   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38999   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39000
39001   arg1 = (Dali::Stage *)jarg1;
39002   {
39003     try {
39004       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39029   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39030   Dali::DevelStage::Rendering arg2 ;
39031
39032   arg1 = (Dali::Stage *)jarg1;
39033   arg2 = (Dali::DevelStage::Rendering)jarg2;
39034   {
39035     try {
39036       DevelStage::SetRenderingBehavior(*arg1,arg2);
39037     } catch (std::out_of_range& e) {
39038       {
39039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39040       };
39041     } catch (std::exception& e) {
39042       {
39043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39044       };
39045     } catch (Dali::DaliException e) {
39046       {
39047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39048       };
39049     } catch (...) {
39050       {
39051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39052       };
39053     }
39054   }
39055
39056 }
39057
39058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39059
39060   int jresult ;
39061   int result ;
39062   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39063
39064   arg1 = (Dali::Stage *)jarg1;
39065   {
39066     try {
39067       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39068     } catch (std::out_of_range& e) {
39069       {
39070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39071       };
39072     } catch (std::exception& e) {
39073       {
39074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39075       };
39076     } catch (Dali::DaliException e) {
39077       {
39078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39079       };
39080     } catch (...) {
39081       {
39082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39083       };
39084     }
39085   }
39086
39087   jresult = result;
39088   return jresult;
39089 }
39090
39091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39092   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39093
39094   arg1 = (Dali::RelayoutContainer *)jarg1;
39095   {
39096     try {
39097       delete arg1;
39098     } catch (std::out_of_range& e) {
39099       {
39100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39101       };
39102     } catch (std::exception& e) {
39103       {
39104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39105       };
39106     } catch (Dali::DaliException e) {
39107       {
39108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39109       };
39110     } catch (...) {
39111       {
39112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39113       };
39114     }
39115   }
39116
39117 }
39118
39119
39120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39121   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39122   Dali::Actor *arg2 = 0 ;
39123   Dali::Vector2 *arg3 = 0 ;
39124
39125   arg1 = (Dali::RelayoutContainer *)jarg1;
39126   arg2 = (Dali::Actor *)jarg2;
39127   if (!arg2) {
39128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39129     return ;
39130   }
39131   arg3 = (Dali::Vector2 *)jarg3;
39132   if (!arg3) {
39133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39134     return ;
39135   }
39136   {
39137     try {
39138       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39139     } catch (std::out_of_range& e) {
39140       {
39141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39142       };
39143     } catch (std::exception& e) {
39144       {
39145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39146       };
39147     } catch (Dali::DaliException e) {
39148       {
39149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39150       };
39151     } catch (...) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39154       };
39155     }
39156   }
39157
39158 }
39159
39160
39161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39162   void * jresult ;
39163   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39164   Dali::CustomActor result;
39165
39166   arg1 = (Dali::CustomActorImpl *)jarg1;
39167   {
39168     try {
39169       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39170     } catch (std::out_of_range& e) {
39171       {
39172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39173       };
39174     } catch (std::exception& e) {
39175       {
39176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39177       };
39178     } catch (Dali::DaliException e) {
39179       {
39180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39181       };
39182     } catch (...) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39185       };
39186     }
39187   }
39188
39189   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39190   return jresult;
39191 }
39192
39193
39194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39195   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39196   int arg2 ;
39197
39198   arg1 = (Dali::CustomActorImpl *)jarg1;
39199   arg2 = (int)jarg2;
39200   {
39201     try {
39202       (arg1)->OnStageConnection(arg2);
39203     } catch (std::out_of_range& e) {
39204       {
39205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39206       };
39207     } catch (std::exception& e) {
39208       {
39209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39210       };
39211     } catch (Dali::DaliException e) {
39212       {
39213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39214       };
39215     } catch (...) {
39216       {
39217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39218       };
39219     }
39220   }
39221
39222 }
39223
39224
39225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39226   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39227
39228   arg1 = (Dali::CustomActorImpl *)jarg1;
39229   {
39230     try {
39231       (arg1)->OnStageDisconnection();
39232     } catch (std::out_of_range& e) {
39233       {
39234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39235       };
39236     } catch (std::exception& e) {
39237       {
39238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39239       };
39240     } catch (Dali::DaliException e) {
39241       {
39242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39243       };
39244     } catch (...) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39247       };
39248     }
39249   }
39250
39251 }
39252
39253
39254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39255   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39256   Dali::Actor *arg2 = 0 ;
39257
39258   arg1 = (Dali::CustomActorImpl *)jarg1;
39259   arg2 = (Dali::Actor *)jarg2;
39260   if (!arg2) {
39261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39262     return ;
39263   }
39264   {
39265     try {
39266       (arg1)->OnChildAdd(*arg2);
39267     } catch (std::out_of_range& e) {
39268       {
39269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39270       };
39271     } catch (std::exception& e) {
39272       {
39273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (Dali::DaliException e) {
39276       {
39277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39278       };
39279     } catch (...) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39282       };
39283     }
39284   }
39285
39286 }
39287
39288
39289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39290   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39291   Dali::Actor *arg2 = 0 ;
39292
39293   arg1 = (Dali::CustomActorImpl *)jarg1;
39294   arg2 = (Dali::Actor *)jarg2;
39295   if (!arg2) {
39296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39297     return ;
39298   }
39299   {
39300     try {
39301       (arg1)->OnChildRemove(*arg2);
39302     } catch (std::out_of_range& e) {
39303       {
39304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39305       };
39306     } catch (std::exception& e) {
39307       {
39308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39309       };
39310     } catch (Dali::DaliException e) {
39311       {
39312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39313       };
39314     } catch (...) {
39315       {
39316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39317       };
39318     }
39319   }
39320
39321 }
39322
39323
39324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39325   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39326   Dali::Property::Index arg2 ;
39327   Dali::Property::Value arg3 ;
39328   Dali::Property::Value *argp3 ;
39329
39330   arg1 = (Dali::CustomActorImpl *)jarg1;
39331   arg2 = (Dali::Property::Index)jarg2;
39332   argp3 = (Dali::Property::Value *)jarg3;
39333   if (!argp3) {
39334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39335     return ;
39336   }
39337   arg3 = *argp3;
39338   {
39339     try {
39340       (arg1)->OnPropertySet(arg2,arg3);
39341     } catch (std::out_of_range& e) {
39342       {
39343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39344       };
39345     } catch (std::exception& e) {
39346       {
39347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39348       };
39349     } catch (Dali::DaliException e) {
39350       {
39351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39352       };
39353     } catch (...) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39356       };
39357     }
39358   }
39359
39360 }
39361
39362
39363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39364   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39365   Dali::Vector3 *arg2 = 0 ;
39366
39367   arg1 = (Dali::CustomActorImpl *)jarg1;
39368   arg2 = (Dali::Vector3 *)jarg2;
39369   if (!arg2) {
39370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39371     return ;
39372   }
39373   {
39374     try {
39375       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39376     } catch (std::out_of_range& e) {
39377       {
39378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39379       };
39380     } catch (std::exception& e) {
39381       {
39382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39383       };
39384     } catch (Dali::DaliException e) {
39385       {
39386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39387       };
39388     } catch (...) {
39389       {
39390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39391       };
39392     }
39393   }
39394
39395 }
39396
39397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39398   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39399   Dali::Animation *arg2 = 0 ;
39400   Dali::Vector3 *arg3 = 0 ;
39401
39402   arg1 = (Dali::CustomActorImpl *)jarg1;
39403   arg2 = (Dali::Animation *)jarg2;
39404   if (!arg2) {
39405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39406     return ;
39407   }
39408   arg3 = (Dali::Vector3 *)jarg3;
39409   if (!arg3) {
39410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39411     return ;
39412   }
39413   {
39414     try {
39415       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39416     } catch (std::out_of_range& e) {
39417       {
39418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39419       };
39420     } catch (std::exception& e) {
39421       {
39422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39423       };
39424     } catch (Dali::DaliException e) {
39425       {
39426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39427       };
39428     } catch (...) {
39429       {
39430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39431       };
39432     }
39433   }
39434
39435 }
39436
39437
39438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39439   unsigned int jresult ;
39440   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39441   Dali::TouchEvent *arg2 = 0 ;
39442   bool result;
39443
39444   arg1 = (Dali::CustomActorImpl *)jarg1;
39445   arg2 = (Dali::TouchEvent *)jarg2;
39446   if (!arg2) {
39447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39448     return 0;
39449   }
39450   {
39451     try {
39452       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39453     } catch (std::out_of_range& e) {
39454       {
39455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39456       };
39457     } catch (std::exception& e) {
39458       {
39459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39460       };
39461     } catch (Dali::DaliException e) {
39462       {
39463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39464       };
39465     } catch (...) {
39466       {
39467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39468       };
39469     }
39470   }
39471
39472   jresult = result;
39473   return jresult;
39474 }
39475
39476
39477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39478   unsigned int jresult ;
39479   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39480   Dali::HoverEvent *arg2 = 0 ;
39481   bool result;
39482
39483   arg1 = (Dali::CustomActorImpl *)jarg1;
39484   arg2 = (Dali::HoverEvent *)jarg2;
39485   if (!arg2) {
39486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39487     return 0;
39488   }
39489   {
39490     try {
39491       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39492     } catch (std::out_of_range& e) {
39493       {
39494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39495       };
39496     } catch (std::exception& e) {
39497       {
39498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39499       };
39500     } catch (Dali::DaliException e) {
39501       {
39502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39503       };
39504     } catch (...) {
39505       {
39506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39507       };
39508     }
39509   }
39510
39511   jresult = result;
39512   return jresult;
39513 }
39514
39515
39516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39517   unsigned int jresult ;
39518   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39519   Dali::KeyEvent *arg2 = 0 ;
39520   bool result;
39521
39522   arg1 = (Dali::CustomActorImpl *)jarg1;
39523   arg2 = (Dali::KeyEvent *)jarg2;
39524   if (!arg2) {
39525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39526     return 0;
39527   }
39528   {
39529     try {
39530       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39531     } catch (std::out_of_range& e) {
39532       {
39533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39534       };
39535     } catch (std::exception& e) {
39536       {
39537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39538       };
39539     } catch (Dali::DaliException e) {
39540       {
39541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39542       };
39543     } catch (...) {
39544       {
39545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39546       };
39547     }
39548   }
39549
39550   jresult = result;
39551   return jresult;
39552 }
39553
39554
39555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39556   unsigned int jresult ;
39557   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39558   Dali::WheelEvent *arg2 = 0 ;
39559   bool result;
39560
39561   arg1 = (Dali::CustomActorImpl *)jarg1;
39562   arg2 = (Dali::WheelEvent *)jarg2;
39563   if (!arg2) {
39564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39565     return 0;
39566   }
39567   {
39568     try {
39569       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39570     } catch (std::out_of_range& e) {
39571       {
39572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39573       };
39574     } catch (std::exception& e) {
39575       {
39576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39577       };
39578     } catch (Dali::DaliException e) {
39579       {
39580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39581       };
39582     } catch (...) {
39583       {
39584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39585       };
39586     }
39587   }
39588
39589   jresult = result;
39590   return jresult;
39591 }
39592
39593
39594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39595   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39596   Dali::Vector2 *arg2 = 0 ;
39597   Dali::RelayoutContainer *arg3 = 0 ;
39598
39599   arg1 = (Dali::CustomActorImpl *)jarg1;
39600   arg2 = (Dali::Vector2 *)jarg2;
39601   if (!arg2) {
39602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39603     return ;
39604   }
39605   arg3 = (Dali::RelayoutContainer *)jarg3;
39606   if (!arg3) {
39607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39608     return ;
39609   }
39610   {
39611     try {
39612       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39613     } catch (std::out_of_range& e) {
39614       {
39615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39616       };
39617     } catch (std::exception& e) {
39618       {
39619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39620       };
39621     } catch (Dali::DaliException e) {
39622       {
39623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39624       };
39625     } catch (...) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39628       };
39629     }
39630   }
39631
39632 }
39633
39634
39635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39636   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39637   Dali::ResizePolicy::Type arg2 ;
39638   Dali::Dimension::Type arg3 ;
39639
39640   arg1 = (Dali::CustomActorImpl *)jarg1;
39641   arg2 = (Dali::ResizePolicy::Type)jarg2;
39642   arg3 = (Dali::Dimension::Type)jarg3;
39643   {
39644     try {
39645       (arg1)->OnSetResizePolicy(arg2,arg3);
39646     } catch (std::out_of_range& e) {
39647       {
39648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39649       };
39650     } catch (std::exception& e) {
39651       {
39652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39653       };
39654     } catch (Dali::DaliException e) {
39655       {
39656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39657       };
39658     } catch (...) {
39659       {
39660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39661       };
39662     }
39663   }
39664
39665 }
39666
39667
39668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39669   void * jresult ;
39670   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39671   Dali::Vector3 result;
39672
39673   arg1 = (Dali::CustomActorImpl *)jarg1;
39674   {
39675     try {
39676       result = (arg1)->GetNaturalSize();
39677     } catch (std::out_of_range& e) {
39678       {
39679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39680       };
39681     } catch (std::exception& e) {
39682       {
39683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39684       };
39685     } catch (Dali::DaliException e) {
39686       {
39687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39688       };
39689     } catch (...) {
39690       {
39691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39692       };
39693     }
39694   }
39695
39696   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39697   return jresult;
39698 }
39699
39700
39701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39702   float jresult ;
39703   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39704   Dali::Actor *arg2 = 0 ;
39705   Dali::Dimension::Type arg3 ;
39706   float result;
39707
39708   arg1 = (Dali::CustomActorImpl *)jarg1;
39709   arg2 = (Dali::Actor *)jarg2;
39710   if (!arg2) {
39711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39712     return 0;
39713   }
39714   arg3 = (Dali::Dimension::Type)jarg3;
39715   {
39716     try {
39717       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39718     } catch (std::out_of_range& e) {
39719       {
39720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39721       };
39722     } catch (std::exception& e) {
39723       {
39724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39725       };
39726     } catch (Dali::DaliException e) {
39727       {
39728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39733       };
39734     }
39735   }
39736
39737   jresult = result;
39738   return jresult;
39739 }
39740
39741
39742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39743   float jresult ;
39744   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39745   float arg2 ;
39746   float result;
39747
39748   arg1 = (Dali::CustomActorImpl *)jarg1;
39749   arg2 = (float)jarg2;
39750   {
39751     try {
39752       result = (float)(arg1)->GetHeightForWidth(arg2);
39753     } catch (std::out_of_range& e) {
39754       {
39755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39756       };
39757     } catch (std::exception& e) {
39758       {
39759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39760       };
39761     } catch (Dali::DaliException e) {
39762       {
39763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39764       };
39765     } catch (...) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39768       };
39769     }
39770   }
39771
39772   jresult = result;
39773   return jresult;
39774 }
39775
39776
39777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39778   float jresult ;
39779   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39780   float arg2 ;
39781   float result;
39782
39783   arg1 = (Dali::CustomActorImpl *)jarg1;
39784   arg2 = (float)jarg2;
39785   {
39786     try {
39787       result = (float)(arg1)->GetWidthForHeight(arg2);
39788     } catch (std::out_of_range& e) {
39789       {
39790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39791       };
39792     } catch (std::exception& e) {
39793       {
39794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39795       };
39796     } catch (Dali::DaliException e) {
39797       {
39798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39799       };
39800     } catch (...) {
39801       {
39802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39803       };
39804     }
39805   }
39806
39807   jresult = result;
39808   return jresult;
39809 }
39810
39811
39812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39813   unsigned int jresult ;
39814   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39815   Dali::Dimension::Type arg2 ;
39816   bool result;
39817
39818   arg1 = (Dali::CustomActorImpl *)jarg1;
39819   arg2 = (Dali::Dimension::Type)jarg2;
39820   {
39821     try {
39822       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39823     } catch (std::out_of_range& e) {
39824       {
39825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39826       };
39827     } catch (std::exception& e) {
39828       {
39829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39830       };
39831     } catch (Dali::DaliException e) {
39832       {
39833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39834       };
39835     } catch (...) {
39836       {
39837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39838       };
39839     }
39840   }
39841
39842   jresult = result;
39843   return jresult;
39844 }
39845
39846
39847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39848   unsigned int jresult ;
39849   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39850   bool result;
39851
39852   arg1 = (Dali::CustomActorImpl *)jarg1;
39853   {
39854     try {
39855       result = (bool)(arg1)->RelayoutDependentOnChildren();
39856     } catch (std::out_of_range& e) {
39857       {
39858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39859       };
39860     } catch (std::exception& e) {
39861       {
39862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39863       };
39864     } catch (Dali::DaliException e) {
39865       {
39866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39867       };
39868     } catch (...) {
39869       {
39870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39871       };
39872     }
39873   }
39874
39875   jresult = result;
39876   return jresult;
39877 }
39878
39879
39880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39881   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39882   Dali::Dimension::Type arg2 ;
39883
39884   arg1 = (Dali::CustomActorImpl *)jarg1;
39885   arg2 = (Dali::Dimension::Type)jarg2;
39886   {
39887     try {
39888       (arg1)->OnCalculateRelayoutSize(arg2);
39889     } catch (std::out_of_range& e) {
39890       {
39891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39892       };
39893     } catch (std::exception& e) {
39894       {
39895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39896       };
39897     } catch (Dali::DaliException e) {
39898       {
39899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39900       };
39901     } catch (...) {
39902       {
39903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39904       };
39905     }
39906   }
39907
39908 }
39909
39910
39911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39912   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39913   float arg2 ;
39914   Dali::Dimension::Type arg3 ;
39915
39916   arg1 = (Dali::CustomActorImpl *)jarg1;
39917   arg2 = (float)jarg2;
39918   arg3 = (Dali::Dimension::Type)jarg3;
39919   {
39920     try {
39921       (arg1)->OnLayoutNegotiated(arg2,arg3);
39922     } catch (std::out_of_range& e) {
39923       {
39924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39925       };
39926     } catch (std::exception& e) {
39927       {
39928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39929       };
39930     } catch (Dali::DaliException e) {
39931       {
39932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39933       };
39934     } catch (...) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39937       };
39938     }
39939   }
39940
39941 }
39942
39943
39944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39945   unsigned int jresult ;
39946   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39947   bool result;
39948
39949   arg1 = (Dali::CustomActorImpl *)jarg1;
39950   {
39951     try {
39952       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39953     } catch (std::out_of_range& e) {
39954       {
39955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39956       };
39957     } catch (std::exception& e) {
39958       {
39959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (Dali::DaliException e) {
39962       {
39963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39964       };
39965     } catch (...) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39968       };
39969     }
39970   }
39971
39972   jresult = result;
39973   return jresult;
39974 }
39975
39976
39977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39978   unsigned int jresult ;
39979   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39980   bool result;
39981
39982   arg1 = (Dali::CustomActorImpl *)jarg1;
39983   {
39984     try {
39985       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39986     } catch (std::out_of_range& e) {
39987       {
39988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39989       };
39990     } catch (std::exception& e) {
39991       {
39992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39993       };
39994     } catch (Dali::DaliException e) {
39995       {
39996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39997       };
39998     } catch (...) {
39999       {
40000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40001       };
40002     }
40003   }
40004
40005   jresult = result;
40006   return jresult;
40007 }
40008
40009
40010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40011   unsigned int jresult ;
40012   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40013   bool result;
40014
40015   arg1 = (Dali::CustomActorImpl *)jarg1;
40016   {
40017     try {
40018       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40019     } catch (std::out_of_range& e) {
40020       {
40021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40022       };
40023     } catch (std::exception& e) {
40024       {
40025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (Dali::DaliException e) {
40028       {
40029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40030       };
40031     } catch (...) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40034       };
40035     }
40036   }
40037
40038   jresult = result;
40039   return jresult;
40040 }
40041
40042
40043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40044   unsigned int jresult ;
40045   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40046   bool result;
40047
40048   arg1 = (Dali::CustomActorImpl *)jarg1;
40049   {
40050     try {
40051       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40052     } catch (std::out_of_range& e) {
40053       {
40054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40055       };
40056     } catch (std::exception& e) {
40057       {
40058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40059       };
40060     } catch (Dali::DaliException e) {
40061       {
40062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40063       };
40064     } catch (...) {
40065       {
40066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40067       };
40068     }
40069   }
40070
40071   jresult = result;
40072   return jresult;
40073 }
40074
40075
40076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40077   void * jresult ;
40078   Dali::CustomActor *result = 0 ;
40079
40080   {
40081     try {
40082       result = (Dali::CustomActor *)new Dali::CustomActor();
40083     } catch (std::out_of_range& e) {
40084       {
40085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40086       };
40087     } catch (std::exception& e) {
40088       {
40089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40090       };
40091     } catch (Dali::DaliException e) {
40092       {
40093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40094       };
40095     } catch (...) {
40096       {
40097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40098       };
40099     }
40100   }
40101
40102   jresult = (void *)result;
40103   return jresult;
40104 }
40105
40106
40107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40108   void * jresult ;
40109   Dali::BaseHandle arg1 ;
40110   Dali::BaseHandle *argp1 ;
40111   Dali::CustomActor result;
40112
40113   argp1 = (Dali::BaseHandle *)jarg1;
40114   if (!argp1) {
40115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40116     return 0;
40117   }
40118   arg1 = *argp1;
40119   {
40120     try {
40121       result = Dali::CustomActor::DownCast(arg1);
40122     } catch (std::out_of_range& e) {
40123       {
40124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40125       };
40126     } catch (std::exception& e) {
40127       {
40128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (Dali::DaliException e) {
40131       {
40132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40133       };
40134     } catch (...) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40137       };
40138     }
40139   }
40140
40141   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40142   return jresult;
40143 }
40144
40145
40146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40147   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40148
40149   arg1 = (Dali::CustomActor *)jarg1;
40150   {
40151     try {
40152       delete arg1;
40153     } catch (std::out_of_range& e) {
40154       {
40155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40156       };
40157     } catch (std::exception& e) {
40158       {
40159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40160       };
40161     } catch (Dali::DaliException e) {
40162       {
40163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40164       };
40165     } catch (...) {
40166       {
40167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40168       };
40169     }
40170   }
40171
40172 }
40173
40174
40175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40176   void * jresult ;
40177   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40178   Dali::CustomActorImpl *result = 0 ;
40179
40180   arg1 = (Dali::CustomActor *)jarg1;
40181   {
40182     try {
40183       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40184     } catch (std::out_of_range& e) {
40185       {
40186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40187       };
40188     } catch (std::exception& e) {
40189       {
40190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (Dali::DaliException e) {
40193       {
40194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40195       };
40196     } catch (...) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40199       };
40200     }
40201   }
40202
40203   jresult = (void *)result;
40204   return jresult;
40205 }
40206
40207
40208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40209   void * jresult ;
40210   Dali::CustomActorImpl *arg1 = 0 ;
40211   Dali::CustomActor *result = 0 ;
40212
40213   arg1 = (Dali::CustomActorImpl *)jarg1;
40214   if (!arg1) {
40215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40216     return 0;
40217   }
40218   {
40219     try {
40220       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40221     } catch (std::out_of_range& e) {
40222       {
40223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40224       };
40225     } catch (std::exception& e) {
40226       {
40227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (Dali::DaliException e) {
40230       {
40231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40232       };
40233     } catch (...) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40236       };
40237     }
40238   }
40239
40240   jresult = (void *)result;
40241   return jresult;
40242 }
40243
40244
40245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40246   void * jresult ;
40247   Dali::CustomActor *arg1 = 0 ;
40248   Dali::CustomActor *result = 0 ;
40249
40250   arg1 = (Dali::CustomActor *)jarg1;
40251   if (!arg1) {
40252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40253     return 0;
40254   }
40255   {
40256     try {
40257       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40258     } catch (std::out_of_range& e) {
40259       {
40260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40261       };
40262     } catch (std::exception& e) {
40263       {
40264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40265       };
40266     } catch (Dali::DaliException e) {
40267       {
40268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40269       };
40270     } catch (...) {
40271       {
40272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40273       };
40274     }
40275   }
40276
40277   jresult = (void *)result;
40278   return jresult;
40279 }
40280
40281
40282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40283   void * jresult ;
40284   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40285   Dali::CustomActor *arg2 = 0 ;
40286   Dali::CustomActor *result = 0 ;
40287
40288   arg1 = (Dali::CustomActor *)jarg1;
40289   arg2 = (Dali::CustomActor *)jarg2;
40290   if (!arg2) {
40291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40292     return 0;
40293   }
40294   {
40295     try {
40296       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40297     } catch (std::out_of_range& e) {
40298       {
40299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40300       };
40301     } catch (std::exception& e) {
40302       {
40303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40304       };
40305     } catch (Dali::DaliException e) {
40306       {
40307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40308       };
40309     } catch (...) {
40310       {
40311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40312       };
40313     }
40314   }
40315
40316   jresult = (void *)result;
40317   return jresult;
40318 }
40319
40320
40321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40322   int jresult ;
40323   int result;
40324
40325   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40326   jresult = (int)result;
40327   return jresult;
40328 }
40329
40330
40331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40332   int jresult ;
40333   int result;
40334
40335   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40336   jresult = (int)result;
40337   return jresult;
40338 }
40339
40340
40341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40342   int jresult ;
40343   int result;
40344
40345   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40346   jresult = (int)result;
40347   return jresult;
40348 }
40349
40350
40351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40352   int jresult ;
40353   int result;
40354
40355   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40356   jresult = (int)result;
40357   return jresult;
40358 }
40359
40360
40361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40362   int jresult ;
40363   int result;
40364
40365   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40366   jresult = (int)result;
40367   return jresult;
40368 }
40369
40370
40371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40372   int jresult ;
40373   int result;
40374
40375   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40376   jresult = (int)result;
40377   return jresult;
40378 }
40379
40380
40381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40382   int jresult ;
40383   int result;
40384
40385   result = (int)Dali::PanGestureDetector::Property::PANNING;
40386   jresult = (int)result;
40387   return jresult;
40388 }
40389
40390
40391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40392   void * jresult ;
40393   Dali::PanGestureDetector::Property *result = 0 ;
40394
40395   {
40396     try {
40397       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40398     } catch (std::out_of_range& e) {
40399       {
40400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40401       };
40402     } catch (std::exception& e) {
40403       {
40404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40405       };
40406     } catch (Dali::DaliException e) {
40407       {
40408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40409       };
40410     } catch (...) {
40411       {
40412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40413       };
40414     }
40415   }
40416
40417   jresult = (void *)result;
40418   return jresult;
40419 }
40420
40421
40422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40423   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40424
40425   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40426   {
40427     try {
40428       delete arg1;
40429     } catch (std::out_of_range& e) {
40430       {
40431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40432       };
40433     } catch (std::exception& e) {
40434       {
40435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40436       };
40437     } catch (Dali::DaliException e) {
40438       {
40439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40440       };
40441     } catch (...) {
40442       {
40443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40444       };
40445     }
40446   }
40447
40448 }
40449
40450
40451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40452   void * jresult ;
40453   Dali::Radian *result = 0 ;
40454
40455   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40456   jresult = (void *)result;
40457   return jresult;
40458 }
40459
40460
40461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40462   void * jresult ;
40463   Dali::Radian *result = 0 ;
40464
40465   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40466   jresult = (void *)result;
40467   return jresult;
40468 }
40469
40470
40471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40472   void * jresult ;
40473   Dali::Radian *result = 0 ;
40474
40475   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40476   jresult = (void *)result;
40477   return jresult;
40478 }
40479
40480
40481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40482   void * jresult ;
40483   Dali::Radian *result = 0 ;
40484
40485   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40486   jresult = (void *)result;
40487   return jresult;
40488 }
40489
40490
40491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40492   void * jresult ;
40493   Dali::Radian *result = 0 ;
40494
40495   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40496   jresult = (void *)result;
40497   return jresult;
40498 }
40499
40500
40501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40502   void * jresult ;
40503   Dali::Radian *result = 0 ;
40504
40505   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40506   jresult = (void *)result;
40507   return jresult;
40508 }
40509
40510
40511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40512   void * jresult ;
40513   Dali::Radian *result = 0 ;
40514
40515   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40516   jresult = (void *)result;
40517   return jresult;
40518 }
40519
40520
40521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40522   void * jresult ;
40523   Dali::PanGestureDetector *result = 0 ;
40524
40525   {
40526     try {
40527       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40528     } catch (std::out_of_range& e) {
40529       {
40530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40531       };
40532     } catch (std::exception& e) {
40533       {
40534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (Dali::DaliException e) {
40537       {
40538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40539       };
40540     } catch (...) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40543       };
40544     }
40545   }
40546
40547   jresult = (void *)result;
40548   return jresult;
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40553   void * jresult ;
40554   Dali::PanGestureDetector result;
40555
40556   {
40557     try {
40558       result = Dali::PanGestureDetector::New();
40559     } catch (std::out_of_range& e) {
40560       {
40561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40562       };
40563     } catch (std::exception& e) {
40564       {
40565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (Dali::DaliException e) {
40568       {
40569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40570       };
40571     } catch (...) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40574       };
40575     }
40576   }
40577
40578   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40579   return jresult;
40580 }
40581
40582
40583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40584   void * jresult ;
40585   Dali::BaseHandle arg1 ;
40586   Dali::BaseHandle *argp1 ;
40587   Dali::PanGestureDetector result;
40588
40589   argp1 = (Dali::BaseHandle *)jarg1;
40590   if (!argp1) {
40591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40592     return 0;
40593   }
40594   arg1 = *argp1;
40595   {
40596     try {
40597       result = Dali::PanGestureDetector::DownCast(arg1);
40598     } catch (std::out_of_range& e) {
40599       {
40600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40601       };
40602     } catch (std::exception& e) {
40603       {
40604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40605       };
40606     } catch (Dali::DaliException e) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40609       };
40610     } catch (...) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40613       };
40614     }
40615   }
40616
40617   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40618   return jresult;
40619 }
40620
40621
40622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40623   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40624
40625   arg1 = (Dali::PanGestureDetector *)jarg1;
40626   {
40627     try {
40628       delete arg1;
40629     } catch (std::out_of_range& e) {
40630       {
40631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40632       };
40633     } catch (std::exception& e) {
40634       {
40635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40636       };
40637     } catch (Dali::DaliException e) {
40638       {
40639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40640       };
40641     } catch (...) {
40642       {
40643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40644       };
40645     }
40646   }
40647
40648 }
40649
40650
40651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40652   void * jresult ;
40653   Dali::PanGestureDetector *arg1 = 0 ;
40654   Dali::PanGestureDetector *result = 0 ;
40655
40656   arg1 = (Dali::PanGestureDetector *)jarg1;
40657   if (!arg1) {
40658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40659     return 0;
40660   }
40661   {
40662     try {
40663       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40664     } catch (std::out_of_range& e) {
40665       {
40666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40667       };
40668     } catch (std::exception& e) {
40669       {
40670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40671       };
40672     } catch (Dali::DaliException e) {
40673       {
40674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40675       };
40676     } catch (...) {
40677       {
40678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40679       };
40680     }
40681   }
40682
40683   jresult = (void *)result;
40684   return jresult;
40685 }
40686
40687
40688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40689   void * jresult ;
40690   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40691   Dali::PanGestureDetector *arg2 = 0 ;
40692   Dali::PanGestureDetector *result = 0 ;
40693
40694   arg1 = (Dali::PanGestureDetector *)jarg1;
40695   arg2 = (Dali::PanGestureDetector *)jarg2;
40696   if (!arg2) {
40697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40698     return 0;
40699   }
40700   {
40701     try {
40702       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40703     } catch (std::out_of_range& e) {
40704       {
40705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40706       };
40707     } catch (std::exception& e) {
40708       {
40709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40710       };
40711     } catch (Dali::DaliException e) {
40712       {
40713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40714       };
40715     } catch (...) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40718       };
40719     }
40720   }
40721
40722   jresult = (void *)result;
40723   return jresult;
40724 }
40725
40726
40727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40728   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40729   unsigned int arg2 ;
40730
40731   arg1 = (Dali::PanGestureDetector *)jarg1;
40732   arg2 = (unsigned int)jarg2;
40733   {
40734     try {
40735       (arg1)->SetMinimumTouchesRequired(arg2);
40736     } catch (std::out_of_range& e) {
40737       {
40738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40739       };
40740     } catch (std::exception& e) {
40741       {
40742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40743       };
40744     } catch (Dali::DaliException e) {
40745       {
40746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40747       };
40748     } catch (...) {
40749       {
40750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40751       };
40752     }
40753   }
40754
40755 }
40756
40757
40758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40759   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40760   unsigned int arg2 ;
40761
40762   arg1 = (Dali::PanGestureDetector *)jarg1;
40763   arg2 = (unsigned int)jarg2;
40764   {
40765     try {
40766       (arg1)->SetMaximumTouchesRequired(arg2);
40767     } catch (std::out_of_range& e) {
40768       {
40769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40770       };
40771     } catch (std::exception& e) {
40772       {
40773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40774       };
40775     } catch (Dali::DaliException e) {
40776       {
40777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40778       };
40779     } catch (...) {
40780       {
40781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40782       };
40783     }
40784   }
40785
40786 }
40787
40788
40789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40790   unsigned int jresult ;
40791   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40792   unsigned int result;
40793
40794   arg1 = (Dali::PanGestureDetector *)jarg1;
40795   {
40796     try {
40797       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40798     } catch (std::out_of_range& e) {
40799       {
40800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40801       };
40802     } catch (std::exception& e) {
40803       {
40804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40805       };
40806     } catch (Dali::DaliException e) {
40807       {
40808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40809       };
40810     } catch (...) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40813       };
40814     }
40815   }
40816
40817   jresult = result;
40818   return jresult;
40819 }
40820
40821
40822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40823   unsigned int jresult ;
40824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40825   unsigned int result;
40826
40827   arg1 = (Dali::PanGestureDetector *)jarg1;
40828   {
40829     try {
40830       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40831     } catch (std::out_of_range& e) {
40832       {
40833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40834       };
40835     } catch (std::exception& e) {
40836       {
40837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40838       };
40839     } catch (Dali::DaliException e) {
40840       {
40841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40842       };
40843     } catch (...) {
40844       {
40845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40846       };
40847     }
40848   }
40849
40850   jresult = result;
40851   return jresult;
40852 }
40853
40854
40855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40856   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40857   Dali::Radian arg2 ;
40858   Dali::Radian arg3 ;
40859   Dali::Radian *argp2 ;
40860   Dali::Radian *argp3 ;
40861
40862   arg1 = (Dali::PanGestureDetector *)jarg1;
40863   argp2 = (Dali::Radian *)jarg2;
40864   if (!argp2) {
40865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40866     return ;
40867   }
40868   arg2 = *argp2;
40869   argp3 = (Dali::Radian *)jarg3;
40870   if (!argp3) {
40871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40872     return ;
40873   }
40874   arg3 = *argp3;
40875   {
40876     try {
40877       (arg1)->AddAngle(arg2,arg3);
40878     } catch (std::out_of_range& e) {
40879       {
40880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40881       };
40882     } catch (std::exception& e) {
40883       {
40884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40885       };
40886     } catch (Dali::DaliException e) {
40887       {
40888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40889       };
40890     } catch (...) {
40891       {
40892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40893       };
40894     }
40895   }
40896
40897 }
40898
40899
40900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40901   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40902   Dali::Radian arg2 ;
40903   Dali::Radian *argp2 ;
40904
40905   arg1 = (Dali::PanGestureDetector *)jarg1;
40906   argp2 = (Dali::Radian *)jarg2;
40907   if (!argp2) {
40908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40909     return ;
40910   }
40911   arg2 = *argp2;
40912   {
40913     try {
40914       (arg1)->AddAngle(arg2);
40915     } catch (std::out_of_range& e) {
40916       {
40917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40918       };
40919     } catch (std::exception& e) {
40920       {
40921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40922       };
40923     } catch (Dali::DaliException e) {
40924       {
40925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40926       };
40927     } catch (...) {
40928       {
40929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40930       };
40931     }
40932   }
40933
40934 }
40935
40936
40937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40938   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40939   Dali::Radian arg2 ;
40940   Dali::Radian arg3 ;
40941   Dali::Radian *argp2 ;
40942   Dali::Radian *argp3 ;
40943
40944   arg1 = (Dali::PanGestureDetector *)jarg1;
40945   argp2 = (Dali::Radian *)jarg2;
40946   if (!argp2) {
40947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40948     return ;
40949   }
40950   arg2 = *argp2;
40951   argp3 = (Dali::Radian *)jarg3;
40952   if (!argp3) {
40953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40954     return ;
40955   }
40956   arg3 = *argp3;
40957   {
40958     try {
40959       (arg1)->AddDirection(arg2,arg3);
40960     } catch (std::out_of_range& e) {
40961       {
40962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40963       };
40964     } catch (std::exception& e) {
40965       {
40966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40967       };
40968     } catch (Dali::DaliException e) {
40969       {
40970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40971       };
40972     } catch (...) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40975       };
40976     }
40977   }
40978
40979 }
40980
40981
40982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40983   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40984   Dali::Radian arg2 ;
40985   Dali::Radian *argp2 ;
40986
40987   arg1 = (Dali::PanGestureDetector *)jarg1;
40988   argp2 = (Dali::Radian *)jarg2;
40989   if (!argp2) {
40990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40991     return ;
40992   }
40993   arg2 = *argp2;
40994   {
40995     try {
40996       (arg1)->AddDirection(arg2);
40997     } catch (std::out_of_range& e) {
40998       {
40999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41000       };
41001     } catch (std::exception& e) {
41002       {
41003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41004       };
41005     } catch (Dali::DaliException e) {
41006       {
41007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41008       };
41009     } catch (...) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41012       };
41013     }
41014   }
41015
41016 }
41017
41018
41019 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41020   unsigned long jresult ;
41021   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41022   size_t result;
41023
41024   arg1 = (Dali::PanGestureDetector *)jarg1;
41025   {
41026     try {
41027       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41028     } catch (std::out_of_range& e) {
41029       {
41030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41031       };
41032     } catch (std::exception& e) {
41033       {
41034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (Dali::DaliException e) {
41037       {
41038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41039       };
41040     } catch (...) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41043       };
41044     }
41045   }
41046
41047   jresult = (unsigned long)result;
41048   return jresult;
41049 }
41050
41051
41052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41053   void * jresult ;
41054   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41055   size_t arg2 ;
41056   Dali::PanGestureDetector::AngleThresholdPair result;
41057
41058   arg1 = (Dali::PanGestureDetector *)jarg1;
41059   arg2 = (size_t)jarg2;
41060   {
41061     try {
41062       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (Dali::DaliException e) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41074       };
41075     } catch (...) {
41076       {
41077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41078       };
41079     }
41080   }
41081
41082   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41083   return jresult;
41084 }
41085
41086
41087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41088   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41089
41090   arg1 = (Dali::PanGestureDetector *)jarg1;
41091   {
41092     try {
41093       (arg1)->ClearAngles();
41094     } catch (std::out_of_range& e) {
41095       {
41096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41097       };
41098     } catch (std::exception& e) {
41099       {
41100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41101       };
41102     } catch (Dali::DaliException e) {
41103       {
41104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41105       };
41106     } catch (...) {
41107       {
41108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41109       };
41110     }
41111   }
41112
41113 }
41114
41115
41116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41117   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41118   Dali::Radian arg2 ;
41119   Dali::Radian *argp2 ;
41120
41121   arg1 = (Dali::PanGestureDetector *)jarg1;
41122   argp2 = (Dali::Radian *)jarg2;
41123   if (!argp2) {
41124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41125     return ;
41126   }
41127   arg2 = *argp2;
41128   {
41129     try {
41130       (arg1)->RemoveAngle(arg2);
41131     } catch (std::out_of_range& e) {
41132       {
41133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41134       };
41135     } catch (std::exception& e) {
41136       {
41137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41138       };
41139     } catch (Dali::DaliException e) {
41140       {
41141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41142       };
41143     } catch (...) {
41144       {
41145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41146       };
41147     }
41148   }
41149
41150 }
41151
41152
41153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41154   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41155   Dali::Radian arg2 ;
41156   Dali::Radian *argp2 ;
41157
41158   arg1 = (Dali::PanGestureDetector *)jarg1;
41159   argp2 = (Dali::Radian *)jarg2;
41160   if (!argp2) {
41161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41162     return ;
41163   }
41164   arg2 = *argp2;
41165   {
41166     try {
41167       (arg1)->RemoveDirection(arg2);
41168     } catch (std::out_of_range& e) {
41169       {
41170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41171       };
41172     } catch (std::exception& e) {
41173       {
41174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41175       };
41176     } catch (Dali::DaliException e) {
41177       {
41178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41179       };
41180     } catch (...) {
41181       {
41182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41183       };
41184     }
41185   }
41186
41187 }
41188
41189
41190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41191   void * jresult ;
41192   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41193   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41194
41195   arg1 = (Dali::PanGestureDetector *)jarg1;
41196   {
41197     try {
41198       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41199     } catch (std::out_of_range& e) {
41200       {
41201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41202       };
41203     } catch (std::exception& e) {
41204       {
41205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41206       };
41207     } catch (Dali::DaliException e) {
41208       {
41209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41210       };
41211     } catch (...) {
41212       {
41213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41214       };
41215     }
41216   }
41217
41218   jresult = (void *)result;
41219   return jresult;
41220 }
41221
41222
41223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41224   Dali::PanGesture *arg1 = 0 ;
41225
41226   arg1 = (Dali::PanGesture *)jarg1;
41227   if (!arg1) {
41228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41229     return ;
41230   }
41231   {
41232     try {
41233       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41234     } catch (std::out_of_range& e) {
41235       {
41236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41237       };
41238     } catch (std::exception& e) {
41239       {
41240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41241       };
41242     } catch (Dali::DaliException e) {
41243       {
41244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41245       };
41246     } catch (...) {
41247       {
41248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41249       };
41250     }
41251   }
41252
41253 }
41254
41255
41256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41257   void * jresult ;
41258   Dali::PanGesture *result = 0 ;
41259
41260   {
41261     try {
41262       result = (Dali::PanGesture *)new Dali::PanGesture();
41263     } catch (std::out_of_range& e) {
41264       {
41265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41266       };
41267     } catch (std::exception& e) {
41268       {
41269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41270       };
41271     } catch (Dali::DaliException e) {
41272       {
41273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41274       };
41275     } catch (...) {
41276       {
41277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41278       };
41279     }
41280   }
41281
41282   jresult = (void *)result;
41283   return jresult;
41284 }
41285
41286
41287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41288   void * jresult ;
41289   Dali::Gesture::State arg1 ;
41290   Dali::PanGesture *result = 0 ;
41291
41292   arg1 = (Dali::Gesture::State)jarg1;
41293   {
41294     try {
41295       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41296     } catch (std::out_of_range& e) {
41297       {
41298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41299       };
41300     } catch (std::exception& e) {
41301       {
41302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (Dali::DaliException e) {
41305       {
41306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41307       };
41308     } catch (...) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41311       };
41312     }
41313   }
41314
41315   jresult = (void *)result;
41316   return jresult;
41317 }
41318
41319
41320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41321   void * jresult ;
41322   Dali::PanGesture *arg1 = 0 ;
41323   Dali::PanGesture *result = 0 ;
41324
41325   arg1 = (Dali::PanGesture *)jarg1;
41326   if (!arg1) {
41327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41328     return 0;
41329   }
41330   {
41331     try {
41332       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41333     } catch (std::out_of_range& e) {
41334       {
41335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41336       };
41337     } catch (std::exception& e) {
41338       {
41339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41340       };
41341     } catch (Dali::DaliException e) {
41342       {
41343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41344       };
41345     } catch (...) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41348       };
41349     }
41350   }
41351
41352   jresult = (void *)result;
41353   return jresult;
41354 }
41355
41356
41357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41358   void * jresult ;
41359   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41360   Dali::PanGesture *arg2 = 0 ;
41361   Dali::PanGesture *result = 0 ;
41362
41363   arg1 = (Dali::PanGesture *)jarg1;
41364   arg2 = (Dali::PanGesture *)jarg2;
41365   if (!arg2) {
41366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41367     return 0;
41368   }
41369   {
41370     try {
41371       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41372     } catch (std::out_of_range& e) {
41373       {
41374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41375       };
41376     } catch (std::exception& e) {
41377       {
41378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41379       };
41380     } catch (Dali::DaliException e) {
41381       {
41382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41383       };
41384     } catch (...) {
41385       {
41386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41387       };
41388     }
41389   }
41390
41391   jresult = (void *)result;
41392   return jresult;
41393 }
41394
41395
41396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41397   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41398
41399   arg1 = (Dali::PanGesture *)jarg1;
41400   {
41401     try {
41402       delete arg1;
41403     } catch (std::out_of_range& e) {
41404       {
41405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41406       };
41407     } catch (std::exception& e) {
41408       {
41409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41410       };
41411     } catch (Dali::DaliException e) {
41412       {
41413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41414       };
41415     } catch (...) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41418       };
41419     }
41420   }
41421
41422 }
41423
41424
41425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41426   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41427   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41428
41429   arg1 = (Dali::PanGesture *)jarg1;
41430   arg2 = (Dali::Vector2 *)jarg2;
41431   if (arg1) (arg1)->velocity = *arg2;
41432 }
41433
41434
41435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41436   void * jresult ;
41437   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41438   Dali::Vector2 *result = 0 ;
41439
41440   arg1 = (Dali::PanGesture *)jarg1;
41441   result = (Dali::Vector2 *)& ((arg1)->velocity);
41442   jresult = (void *)result;
41443   return jresult;
41444 }
41445
41446
41447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41448   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41449   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41450
41451   arg1 = (Dali::PanGesture *)jarg1;
41452   arg2 = (Dali::Vector2 *)jarg2;
41453   if (arg1) (arg1)->displacement = *arg2;
41454 }
41455
41456
41457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41458   void * jresult ;
41459   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41460   Dali::Vector2 *result = 0 ;
41461
41462   arg1 = (Dali::PanGesture *)jarg1;
41463   result = (Dali::Vector2 *)& ((arg1)->displacement);
41464   jresult = (void *)result;
41465   return jresult;
41466 }
41467
41468
41469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41470   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41471   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41472
41473   arg1 = (Dali::PanGesture *)jarg1;
41474   arg2 = (Dali::Vector2 *)jarg2;
41475   if (arg1) (arg1)->position = *arg2;
41476 }
41477
41478
41479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41480   void * jresult ;
41481   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41482   Dali::Vector2 *result = 0 ;
41483
41484   arg1 = (Dali::PanGesture *)jarg1;
41485   result = (Dali::Vector2 *)& ((arg1)->position);
41486   jresult = (void *)result;
41487   return jresult;
41488 }
41489
41490
41491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41492   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41493   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41494
41495   arg1 = (Dali::PanGesture *)jarg1;
41496   arg2 = (Dali::Vector2 *)jarg2;
41497   if (arg1) (arg1)->screenVelocity = *arg2;
41498 }
41499
41500
41501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41502   void * jresult ;
41503   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41504   Dali::Vector2 *result = 0 ;
41505
41506   arg1 = (Dali::PanGesture *)jarg1;
41507   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41508   jresult = (void *)result;
41509   return jresult;
41510 }
41511
41512
41513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41514   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41515   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41516
41517   arg1 = (Dali::PanGesture *)jarg1;
41518   arg2 = (Dali::Vector2 *)jarg2;
41519   if (arg1) (arg1)->screenDisplacement = *arg2;
41520 }
41521
41522
41523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41524   void * jresult ;
41525   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41526   Dali::Vector2 *result = 0 ;
41527
41528   arg1 = (Dali::PanGesture *)jarg1;
41529   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41530   jresult = (void *)result;
41531   return jresult;
41532 }
41533
41534
41535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41536   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41537   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41538
41539   arg1 = (Dali::PanGesture *)jarg1;
41540   arg2 = (Dali::Vector2 *)jarg2;
41541   if (arg1) (arg1)->screenPosition = *arg2;
41542 }
41543
41544
41545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41546   void * jresult ;
41547   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41548   Dali::Vector2 *result = 0 ;
41549
41550   arg1 = (Dali::PanGesture *)jarg1;
41551   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41552   jresult = (void *)result;
41553   return jresult;
41554 }
41555
41556
41557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41558   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41559   unsigned int arg2 ;
41560
41561   arg1 = (Dali::PanGesture *)jarg1;
41562   arg2 = (unsigned int)jarg2;
41563   if (arg1) (arg1)->numberOfTouches = arg2;
41564 }
41565
41566
41567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41568   unsigned int jresult ;
41569   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41570   unsigned int result;
41571
41572   arg1 = (Dali::PanGesture *)jarg1;
41573   result = (unsigned int) ((arg1)->numberOfTouches);
41574   jresult = result;
41575   return jresult;
41576 }
41577
41578
41579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41580   float jresult ;
41581   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41582   float result;
41583
41584   arg1 = (Dali::PanGesture *)jarg1;
41585   {
41586     try {
41587       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41588     } catch (std::out_of_range& e) {
41589       {
41590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41591       };
41592     } catch (std::exception& e) {
41593       {
41594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41595       };
41596     } catch (Dali::DaliException e) {
41597       {
41598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41599       };
41600     } catch (...) {
41601       {
41602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41603       };
41604     }
41605   }
41606
41607   jresult = result;
41608   return jresult;
41609 }
41610
41611
41612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41613   float jresult ;
41614   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41615   float result;
41616
41617   arg1 = (Dali::PanGesture *)jarg1;
41618   {
41619     try {
41620       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41621     } catch (std::out_of_range& e) {
41622       {
41623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41624       };
41625     } catch (std::exception& e) {
41626       {
41627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41628       };
41629     } catch (Dali::DaliException e) {
41630       {
41631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41632       };
41633     } catch (...) {
41634       {
41635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41636       };
41637     }
41638   }
41639
41640   jresult = result;
41641   return jresult;
41642 }
41643
41644
41645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41646   float jresult ;
41647   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41648   float result;
41649
41650   arg1 = (Dali::PanGesture *)jarg1;
41651   {
41652     try {
41653       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41654     } catch (std::out_of_range& e) {
41655       {
41656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41657       };
41658     } catch (std::exception& e) {
41659       {
41660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41661       };
41662     } catch (Dali::DaliException e) {
41663       {
41664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41665       };
41666     } catch (...) {
41667       {
41668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41669       };
41670     }
41671   }
41672
41673   jresult = result;
41674   return jresult;
41675 }
41676
41677
41678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41679   float jresult ;
41680   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41681   float result;
41682
41683   arg1 = (Dali::PanGesture *)jarg1;
41684   {
41685     try {
41686       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41687     } catch (std::out_of_range& e) {
41688       {
41689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41690       };
41691     } catch (std::exception& e) {
41692       {
41693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41694       };
41695     } catch (Dali::DaliException e) {
41696       {
41697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41698       };
41699     } catch (...) {
41700       {
41701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41702       };
41703     }
41704   }
41705
41706   jresult = result;
41707   return jresult;
41708 }
41709
41710
41711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41712   void * jresult ;
41713   Dali::PinchGestureDetector *result = 0 ;
41714
41715   {
41716     try {
41717       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41718     } catch (std::out_of_range& e) {
41719       {
41720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41721       };
41722     } catch (std::exception& e) {
41723       {
41724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41725       };
41726     } catch (Dali::DaliException e) {
41727       {
41728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41729       };
41730     } catch (...) {
41731       {
41732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41733       };
41734     }
41735   }
41736
41737   jresult = (void *)result;
41738   return jresult;
41739 }
41740
41741
41742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41743   void * jresult ;
41744   Dali::PinchGestureDetector result;
41745
41746   {
41747     try {
41748       result = Dali::PinchGestureDetector::New();
41749     } catch (std::out_of_range& e) {
41750       {
41751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41752       };
41753     } catch (std::exception& e) {
41754       {
41755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (Dali::DaliException e) {
41758       {
41759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41760       };
41761     } catch (...) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41764       };
41765     }
41766   }
41767
41768   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41769   return jresult;
41770 }
41771
41772
41773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41774   void * jresult ;
41775   Dali::BaseHandle arg1 ;
41776   Dali::BaseHandle *argp1 ;
41777   Dali::PinchGestureDetector result;
41778
41779   argp1 = (Dali::BaseHandle *)jarg1;
41780   if (!argp1) {
41781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41782     return 0;
41783   }
41784   arg1 = *argp1;
41785   {
41786     try {
41787       result = Dali::PinchGestureDetector::DownCast(arg1);
41788     } catch (std::out_of_range& e) {
41789       {
41790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (std::exception& e) {
41793       {
41794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (Dali::DaliException e) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41799       };
41800     } catch (...) {
41801       {
41802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41803       };
41804     }
41805   }
41806
41807   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41813   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41814
41815   arg1 = (Dali::PinchGestureDetector *)jarg1;
41816   {
41817     try {
41818       delete arg1;
41819     } catch (std::out_of_range& e) {
41820       {
41821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41822       };
41823     } catch (std::exception& e) {
41824       {
41825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41826       };
41827     } catch (Dali::DaliException e) {
41828       {
41829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41830       };
41831     } catch (...) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41834       };
41835     }
41836   }
41837
41838 }
41839
41840
41841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41842   void * jresult ;
41843   Dali::PinchGestureDetector *arg1 = 0 ;
41844   Dali::PinchGestureDetector *result = 0 ;
41845
41846   arg1 = (Dali::PinchGestureDetector *)jarg1;
41847   if (!arg1) {
41848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41849     return 0;
41850   }
41851   {
41852     try {
41853       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41854     } catch (std::out_of_range& e) {
41855       {
41856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41857       };
41858     } catch (std::exception& e) {
41859       {
41860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41861       };
41862     } catch (Dali::DaliException e) {
41863       {
41864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41865       };
41866     } catch (...) {
41867       {
41868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41869       };
41870     }
41871   }
41872
41873   jresult = (void *)result;
41874   return jresult;
41875 }
41876
41877
41878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41879   void * jresult ;
41880   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41881   Dali::PinchGestureDetector *arg2 = 0 ;
41882   Dali::PinchGestureDetector *result = 0 ;
41883
41884   arg1 = (Dali::PinchGestureDetector *)jarg1;
41885   arg2 = (Dali::PinchGestureDetector *)jarg2;
41886   if (!arg2) {
41887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41888     return 0;
41889   }
41890   {
41891     try {
41892       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (Dali::DaliException e) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41904       };
41905     } catch (...) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41908       };
41909     }
41910   }
41911
41912   jresult = (void *)result;
41913   return jresult;
41914 }
41915
41916
41917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41918   void * jresult ;
41919   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41920   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41921
41922   arg1 = (Dali::PinchGestureDetector *)jarg1;
41923   {
41924     try {
41925       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41926     } catch (std::out_of_range& e) {
41927       {
41928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41929       };
41930     } catch (std::exception& e) {
41931       {
41932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (Dali::DaliException e) {
41935       {
41936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41937       };
41938     } catch (...) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41941       };
41942     }
41943   }
41944
41945   jresult = (void *)result;
41946   return jresult;
41947 }
41948
41949
41950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41951   void * jresult ;
41952   Dali::Gesture::State arg1 ;
41953   Dali::PinchGesture *result = 0 ;
41954
41955   arg1 = (Dali::Gesture::State)jarg1;
41956   {
41957     try {
41958       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41959     } catch (std::out_of_range& e) {
41960       {
41961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41962       };
41963     } catch (std::exception& e) {
41964       {
41965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41966       };
41967     } catch (Dali::DaliException e) {
41968       {
41969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41970       };
41971     } catch (...) {
41972       {
41973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41974       };
41975     }
41976   }
41977
41978   jresult = (void *)result;
41979   return jresult;
41980 }
41981
41982
41983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41984   void * jresult ;
41985   Dali::PinchGesture *arg1 = 0 ;
41986   Dali::PinchGesture *result = 0 ;
41987
41988   arg1 = (Dali::PinchGesture *)jarg1;
41989   if (!arg1) {
41990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41991     return 0;
41992   }
41993   {
41994     try {
41995       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41996     } catch (std::out_of_range& e) {
41997       {
41998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41999       };
42000     } catch (std::exception& e) {
42001       {
42002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42003       };
42004     } catch (Dali::DaliException e) {
42005       {
42006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42007       };
42008     } catch (...) {
42009       {
42010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42011       };
42012     }
42013   }
42014
42015   jresult = (void *)result;
42016   return jresult;
42017 }
42018
42019
42020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42021   void * jresult ;
42022   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42023   Dali::PinchGesture *arg2 = 0 ;
42024   Dali::PinchGesture *result = 0 ;
42025
42026   arg1 = (Dali::PinchGesture *)jarg1;
42027   arg2 = (Dali::PinchGesture *)jarg2;
42028   if (!arg2) {
42029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42030     return 0;
42031   }
42032   {
42033     try {
42034       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42035     } catch (std::out_of_range& e) {
42036       {
42037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42038       };
42039     } catch (std::exception& e) {
42040       {
42041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42042       };
42043     } catch (Dali::DaliException e) {
42044       {
42045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42046       };
42047     } catch (...) {
42048       {
42049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42050       };
42051     }
42052   }
42053
42054   jresult = (void *)result;
42055   return jresult;
42056 }
42057
42058
42059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42060   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42061
42062   arg1 = (Dali::PinchGesture *)jarg1;
42063   {
42064     try {
42065       delete arg1;
42066     } catch (std::out_of_range& e) {
42067       {
42068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42069       };
42070     } catch (std::exception& e) {
42071       {
42072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42073       };
42074     } catch (Dali::DaliException e) {
42075       {
42076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42077       };
42078     } catch (...) {
42079       {
42080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42081       };
42082     }
42083   }
42084
42085 }
42086
42087
42088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42089   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42090   float arg2 ;
42091
42092   arg1 = (Dali::PinchGesture *)jarg1;
42093   arg2 = (float)jarg2;
42094   if (arg1) (arg1)->scale = arg2;
42095 }
42096
42097
42098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42099   float jresult ;
42100   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42101   float result;
42102
42103   arg1 = (Dali::PinchGesture *)jarg1;
42104   result = (float) ((arg1)->scale);
42105   jresult = result;
42106   return jresult;
42107 }
42108
42109
42110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42111   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42112   float arg2 ;
42113
42114   arg1 = (Dali::PinchGesture *)jarg1;
42115   arg2 = (float)jarg2;
42116   if (arg1) (arg1)->speed = arg2;
42117 }
42118
42119
42120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42121   float jresult ;
42122   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42123   float result;
42124
42125   arg1 = (Dali::PinchGesture *)jarg1;
42126   result = (float) ((arg1)->speed);
42127   jresult = result;
42128   return jresult;
42129 }
42130
42131
42132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42133   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42134   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42135
42136   arg1 = (Dali::PinchGesture *)jarg1;
42137   arg2 = (Dali::Vector2 *)jarg2;
42138   if (arg1) (arg1)->screenCenterPoint = *arg2;
42139 }
42140
42141
42142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42143   void * jresult ;
42144   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42145   Dali::Vector2 *result = 0 ;
42146
42147   arg1 = (Dali::PinchGesture *)jarg1;
42148   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42149   jresult = (void *)result;
42150   return jresult;
42151 }
42152
42153
42154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42155   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42156   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42157
42158   arg1 = (Dali::PinchGesture *)jarg1;
42159   arg2 = (Dali::Vector2 *)jarg2;
42160   if (arg1) (arg1)->localCenterPoint = *arg2;
42161 }
42162
42163
42164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42165   void * jresult ;
42166   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42167   Dali::Vector2 *result = 0 ;
42168
42169   arg1 = (Dali::PinchGesture *)jarg1;
42170   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42171   jresult = (void *)result;
42172   return jresult;
42173 }
42174
42175
42176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42177   void * jresult ;
42178   Dali::TapGestureDetector *result = 0 ;
42179
42180   {
42181     try {
42182       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42183     } catch (std::out_of_range& e) {
42184       {
42185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42186       };
42187     } catch (std::exception& e) {
42188       {
42189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42190       };
42191     } catch (Dali::DaliException e) {
42192       {
42193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42194       };
42195     } catch (...) {
42196       {
42197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42198       };
42199     }
42200   }
42201
42202   jresult = (void *)result;
42203   return jresult;
42204 }
42205
42206
42207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42208   void * jresult ;
42209   Dali::TapGestureDetector result;
42210
42211   {
42212     try {
42213       result = Dali::TapGestureDetector::New();
42214     } catch (std::out_of_range& e) {
42215       {
42216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42217       };
42218     } catch (std::exception& e) {
42219       {
42220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42221       };
42222     } catch (Dali::DaliException e) {
42223       {
42224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42225       };
42226     } catch (...) {
42227       {
42228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42229       };
42230     }
42231   }
42232
42233   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42234   return jresult;
42235 }
42236
42237
42238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42239   void * jresult ;
42240   unsigned int arg1 ;
42241   Dali::TapGestureDetector result;
42242
42243   arg1 = (unsigned int)jarg1;
42244   {
42245     try {
42246       result = Dali::TapGestureDetector::New(arg1);
42247     } catch (std::out_of_range& e) {
42248       {
42249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42250       };
42251     } catch (std::exception& e) {
42252       {
42253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42254       };
42255     } catch (Dali::DaliException e) {
42256       {
42257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42258       };
42259     } catch (...) {
42260       {
42261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42262       };
42263     }
42264   }
42265
42266   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42267   return jresult;
42268 }
42269
42270
42271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42272   void * jresult ;
42273   Dali::BaseHandle arg1 ;
42274   Dali::BaseHandle *argp1 ;
42275   Dali::TapGestureDetector result;
42276
42277   argp1 = (Dali::BaseHandle *)jarg1;
42278   if (!argp1) {
42279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42280     return 0;
42281   }
42282   arg1 = *argp1;
42283   {
42284     try {
42285       result = Dali::TapGestureDetector::DownCast(arg1);
42286     } catch (std::out_of_range& e) {
42287       {
42288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42289       };
42290     } catch (std::exception& e) {
42291       {
42292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42293       };
42294     } catch (Dali::DaliException e) {
42295       {
42296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42297       };
42298     } catch (...) {
42299       {
42300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42301       };
42302     }
42303   }
42304
42305   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42306   return jresult;
42307 }
42308
42309
42310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42311   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42312
42313   arg1 = (Dali::TapGestureDetector *)jarg1;
42314   {
42315     try {
42316       delete arg1;
42317     } catch (std::out_of_range& e) {
42318       {
42319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42320       };
42321     } catch (std::exception& e) {
42322       {
42323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42324       };
42325     } catch (Dali::DaliException e) {
42326       {
42327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42328       };
42329     } catch (...) {
42330       {
42331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42332       };
42333     }
42334   }
42335
42336 }
42337
42338
42339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42340   void * jresult ;
42341   Dali::TapGestureDetector *arg1 = 0 ;
42342   Dali::TapGestureDetector *result = 0 ;
42343
42344   arg1 = (Dali::TapGestureDetector *)jarg1;
42345   if (!arg1) {
42346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42347     return 0;
42348   }
42349   {
42350     try {
42351       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42352     } catch (std::out_of_range& e) {
42353       {
42354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42355       };
42356     } catch (std::exception& e) {
42357       {
42358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42359       };
42360     } catch (Dali::DaliException e) {
42361       {
42362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42363       };
42364     } catch (...) {
42365       {
42366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42367       };
42368     }
42369   }
42370
42371   jresult = (void *)result;
42372   return jresult;
42373 }
42374
42375
42376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42377   void * jresult ;
42378   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42379   Dali::TapGestureDetector *arg2 = 0 ;
42380   Dali::TapGestureDetector *result = 0 ;
42381
42382   arg1 = (Dali::TapGestureDetector *)jarg1;
42383   arg2 = (Dali::TapGestureDetector *)jarg2;
42384   if (!arg2) {
42385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42386     return 0;
42387   }
42388   {
42389     try {
42390       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42391     } catch (std::out_of_range& e) {
42392       {
42393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42394       };
42395     } catch (std::exception& e) {
42396       {
42397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42398       };
42399     } catch (Dali::DaliException e) {
42400       {
42401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42402       };
42403     } catch (...) {
42404       {
42405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42406       };
42407     }
42408   }
42409
42410   jresult = (void *)result;
42411   return jresult;
42412 }
42413
42414
42415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42416   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42417   unsigned int arg2 ;
42418
42419   arg1 = (Dali::TapGestureDetector *)jarg1;
42420   arg2 = (unsigned int)jarg2;
42421   {
42422     try {
42423       (arg1)->SetMinimumTapsRequired(arg2);
42424     } catch (std::out_of_range& e) {
42425       {
42426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42427       };
42428     } catch (std::exception& e) {
42429       {
42430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42431       };
42432     } catch (Dali::DaliException e) {
42433       {
42434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42435       };
42436     } catch (...) {
42437       {
42438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42439       };
42440     }
42441   }
42442
42443 }
42444
42445
42446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42447   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42448   unsigned int arg2 ;
42449
42450   arg1 = (Dali::TapGestureDetector *)jarg1;
42451   arg2 = (unsigned int)jarg2;
42452   {
42453     try {
42454       (arg1)->SetMaximumTapsRequired(arg2);
42455     } catch (std::out_of_range& e) {
42456       {
42457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42458       };
42459     } catch (std::exception& e) {
42460       {
42461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42462       };
42463     } catch (Dali::DaliException e) {
42464       {
42465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42466       };
42467     } catch (...) {
42468       {
42469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42470       };
42471     }
42472   }
42473
42474 }
42475
42476
42477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42478   unsigned int jresult ;
42479   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42480   unsigned int result;
42481
42482   arg1 = (Dali::TapGestureDetector *)jarg1;
42483   {
42484     try {
42485       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42486     } catch (std::out_of_range& e) {
42487       {
42488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42489       };
42490     } catch (std::exception& e) {
42491       {
42492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42493       };
42494     } catch (Dali::DaliException e) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42497       };
42498     } catch (...) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42501       };
42502     }
42503   }
42504
42505   jresult = result;
42506   return jresult;
42507 }
42508
42509
42510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42511   unsigned int jresult ;
42512   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42513   unsigned int result;
42514
42515   arg1 = (Dali::TapGestureDetector *)jarg1;
42516   {
42517     try {
42518       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42519     } catch (std::out_of_range& e) {
42520       {
42521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (std::exception& e) {
42524       {
42525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42526       };
42527     } catch (Dali::DaliException e) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42530       };
42531     } catch (...) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42534       };
42535     }
42536   }
42537
42538   jresult = result;
42539   return jresult;
42540 }
42541
42542
42543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42544   void * jresult ;
42545   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42546   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42547
42548   arg1 = (Dali::TapGestureDetector *)jarg1;
42549   {
42550     try {
42551       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42552     } catch (std::out_of_range& e) {
42553       {
42554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42555       };
42556     } catch (std::exception& e) {
42557       {
42558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42559       };
42560     } catch (Dali::DaliException e) {
42561       {
42562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42563       };
42564     } catch (...) {
42565       {
42566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42567       };
42568     }
42569   }
42570
42571   jresult = (void *)result;
42572   return jresult;
42573 }
42574
42575
42576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42577   void * jresult ;
42578   Dali::TapGesture *result = 0 ;
42579
42580   {
42581     try {
42582       result = (Dali::TapGesture *)new Dali::TapGesture();
42583     } catch (std::out_of_range& e) {
42584       {
42585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42586       };
42587     } catch (std::exception& e) {
42588       {
42589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42590       };
42591     } catch (Dali::DaliException e) {
42592       {
42593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42594       };
42595     } catch (...) {
42596       {
42597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42598       };
42599     }
42600   }
42601
42602   jresult = (void *)result;
42603   return jresult;
42604 }
42605
42606
42607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42608   void * jresult ;
42609   Dali::TapGesture *arg1 = 0 ;
42610   Dali::TapGesture *result = 0 ;
42611
42612   arg1 = (Dali::TapGesture *)jarg1;
42613   if (!arg1) {
42614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42615     return 0;
42616   }
42617   {
42618     try {
42619       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42620     } catch (std::out_of_range& e) {
42621       {
42622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42623       };
42624     } catch (std::exception& e) {
42625       {
42626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (Dali::DaliException e) {
42629       {
42630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42631       };
42632     } catch (...) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42635       };
42636     }
42637   }
42638
42639   jresult = (void *)result;
42640   return jresult;
42641 }
42642
42643
42644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42645   void * jresult ;
42646   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42647   Dali::TapGesture *arg2 = 0 ;
42648   Dali::TapGesture *result = 0 ;
42649
42650   arg1 = (Dali::TapGesture *)jarg1;
42651   arg2 = (Dali::TapGesture *)jarg2;
42652   if (!arg2) {
42653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42654     return 0;
42655   }
42656   {
42657     try {
42658       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42659     } catch (std::out_of_range& e) {
42660       {
42661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (std::exception& e) {
42664       {
42665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42666       };
42667     } catch (Dali::DaliException e) {
42668       {
42669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42670       };
42671     } catch (...) {
42672       {
42673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42674       };
42675     }
42676   }
42677
42678   jresult = (void *)result;
42679   return jresult;
42680 }
42681
42682
42683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42684   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42685
42686   arg1 = (Dali::TapGesture *)jarg1;
42687   {
42688     try {
42689       delete arg1;
42690     } catch (std::out_of_range& e) {
42691       {
42692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42693       };
42694     } catch (std::exception& e) {
42695       {
42696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42697       };
42698     } catch (Dali::DaliException e) {
42699       {
42700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42701       };
42702     } catch (...) {
42703       {
42704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42705       };
42706     }
42707   }
42708
42709 }
42710
42711
42712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42713   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42714   unsigned int arg2 ;
42715
42716   arg1 = (Dali::TapGesture *)jarg1;
42717   arg2 = (unsigned int)jarg2;
42718   if (arg1) (arg1)->numberOfTaps = arg2;
42719 }
42720
42721
42722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42723   unsigned int jresult ;
42724   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42725   unsigned int result;
42726
42727   arg1 = (Dali::TapGesture *)jarg1;
42728   result = (unsigned int) ((arg1)->numberOfTaps);
42729   jresult = result;
42730   return jresult;
42731 }
42732
42733
42734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42735   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42736   unsigned int arg2 ;
42737
42738   arg1 = (Dali::TapGesture *)jarg1;
42739   arg2 = (unsigned int)jarg2;
42740   if (arg1) (arg1)->numberOfTouches = arg2;
42741 }
42742
42743
42744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42745   unsigned int jresult ;
42746   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42747   unsigned int result;
42748
42749   arg1 = (Dali::TapGesture *)jarg1;
42750   result = (unsigned int) ((arg1)->numberOfTouches);
42751   jresult = result;
42752   return jresult;
42753 }
42754
42755
42756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42757   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42758   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42759
42760   arg1 = (Dali::TapGesture *)jarg1;
42761   arg2 = (Dali::Vector2 *)jarg2;
42762   if (arg1) (arg1)->screenPoint = *arg2;
42763 }
42764
42765
42766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42767   void * jresult ;
42768   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42769   Dali::Vector2 *result = 0 ;
42770
42771   arg1 = (Dali::TapGesture *)jarg1;
42772   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42773   jresult = (void *)result;
42774   return jresult;
42775 }
42776
42777
42778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42779   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42780   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42781
42782   arg1 = (Dali::TapGesture *)jarg1;
42783   arg2 = (Dali::Vector2 *)jarg2;
42784   if (arg1) (arg1)->localPoint = *arg2;
42785 }
42786
42787
42788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42789   void * jresult ;
42790   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42791   Dali::Vector2 *result = 0 ;
42792
42793   arg1 = (Dali::TapGesture *)jarg1;
42794   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42795   jresult = (void *)result;
42796   return jresult;
42797 }
42798
42799
42800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42801   void * jresult ;
42802   Dali::AlphaFunction *result = 0 ;
42803
42804   {
42805     try {
42806       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42807     } catch (std::out_of_range& e) {
42808       {
42809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42810       };
42811     } catch (std::exception& e) {
42812       {
42813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42814       };
42815     } catch (Dali::DaliException e) {
42816       {
42817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42818       };
42819     } catch (...) {
42820       {
42821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42822       };
42823     }
42824   }
42825
42826   jresult = (void *)result;
42827   return jresult;
42828 }
42829
42830
42831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42832   void * jresult ;
42833   Dali::AlphaFunction::BuiltinFunction arg1 ;
42834   Dali::AlphaFunction *result = 0 ;
42835
42836   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42837   {
42838     try {
42839       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42840     } catch (std::out_of_range& e) {
42841       {
42842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42843       };
42844     } catch (std::exception& e) {
42845       {
42846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42847       };
42848     } catch (Dali::DaliException e) {
42849       {
42850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42851       };
42852     } catch (...) {
42853       {
42854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42855       };
42856     }
42857   }
42858
42859   jresult = (void *)result;
42860   return jresult;
42861 }
42862
42863
42864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42865   void * jresult ;
42866   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42867   Dali::AlphaFunction *result = 0 ;
42868
42869   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42870   {
42871     try {
42872       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42873     } catch (std::out_of_range& e) {
42874       {
42875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42876       };
42877     } catch (std::exception& e) {
42878       {
42879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (Dali::DaliException e) {
42882       {
42883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42884       };
42885     } catch (...) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42888       };
42889     }
42890   }
42891
42892   jresult = (void *)result;
42893   return jresult;
42894 }
42895
42896
42897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42898   void * jresult ;
42899   Dali::Vector2 *arg1 = 0 ;
42900   Dali::Vector2 *arg2 = 0 ;
42901   Dali::AlphaFunction *result = 0 ;
42902
42903   arg1 = (Dali::Vector2 *)jarg1;
42904   if (!arg1) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42906     return 0;
42907   }
42908   arg2 = (Dali::Vector2 *)jarg2;
42909   if (!arg2) {
42910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42911     return 0;
42912   }
42913   {
42914     try {
42915       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42916     } catch (std::out_of_range& e) {
42917       {
42918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42919       };
42920     } catch (std::exception& e) {
42921       {
42922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (Dali::DaliException e) {
42925       {
42926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42927       };
42928     } catch (...) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42931       };
42932     }
42933   }
42934
42935   jresult = (void *)result;
42936   return jresult;
42937 }
42938
42939
42940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42941   void * jresult ;
42942   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42943   Dali::Vector4 result;
42944
42945   arg1 = (Dali::AlphaFunction *)jarg1;
42946   {
42947     try {
42948       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42949     } catch (std::out_of_range& e) {
42950       {
42951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42952       };
42953     } catch (std::exception& e) {
42954       {
42955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42956       };
42957     } catch (Dali::DaliException e) {
42958       {
42959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42960       };
42961     } catch (...) {
42962       {
42963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42964       };
42965     }
42966   }
42967
42968   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42969   return jresult;
42970 }
42971
42972
42973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42974   void * jresult ;
42975   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42976   Dali::AlphaFunctionPrototype result;
42977
42978   arg1 = (Dali::AlphaFunction *)jarg1;
42979   {
42980     try {
42981       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42982     } catch (std::out_of_range& e) {
42983       {
42984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42985       };
42986     } catch (std::exception& e) {
42987       {
42988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42989       };
42990     } catch (Dali::DaliException e) {
42991       {
42992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42993       };
42994     } catch (...) {
42995       {
42996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42997       };
42998     }
42999   }
43000
43001   jresult = (void *)result;
43002   return jresult;
43003 }
43004
43005
43006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43007   int jresult ;
43008   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43009   Dali::AlphaFunction::BuiltinFunction result;
43010
43011   arg1 = (Dali::AlphaFunction *)jarg1;
43012   {
43013     try {
43014       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43015     } catch (std::out_of_range& e) {
43016       {
43017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43018       };
43019     } catch (std::exception& e) {
43020       {
43021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43022       };
43023     } catch (Dali::DaliException e) {
43024       {
43025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43026       };
43027     } catch (...) {
43028       {
43029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43030       };
43031     }
43032   }
43033
43034   jresult = (int)result;
43035   return jresult;
43036 }
43037
43038
43039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43040   int jresult ;
43041   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43042   Dali::AlphaFunction::Mode result;
43043
43044   arg1 = (Dali::AlphaFunction *)jarg1;
43045   {
43046     try {
43047       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43048     } catch (std::out_of_range& e) {
43049       {
43050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43051       };
43052     } catch (std::exception& e) {
43053       {
43054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43055       };
43056     } catch (Dali::DaliException e) {
43057       {
43058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43059       };
43060     } catch (...) {
43061       {
43062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43063       };
43064     }
43065   }
43066
43067   jresult = (int)result;
43068   return jresult;
43069 }
43070
43071
43072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43073   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43074
43075   arg1 = (Dali::AlphaFunction *)jarg1;
43076   {
43077     try {
43078       delete arg1;
43079     } catch (std::out_of_range& e) {
43080       {
43081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43082       };
43083     } catch (std::exception& e) {
43084       {
43085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (Dali::DaliException e) {
43088       {
43089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43090       };
43091     } catch (...) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43094       };
43095     }
43096   }
43097
43098 }
43099
43100
43101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43102   void * jresult ;
43103   Dali::KeyFrames result;
43104
43105   {
43106     try {
43107       result = Dali::KeyFrames::New();
43108     } catch (std::out_of_range& e) {
43109       {
43110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43111       };
43112     } catch (std::exception& e) {
43113       {
43114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43115       };
43116     } catch (Dali::DaliException e) {
43117       {
43118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43119       };
43120     } catch (...) {
43121       {
43122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43123       };
43124     }
43125   }
43126
43127   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43128   return jresult;
43129 }
43130
43131
43132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43133   void * jresult ;
43134   Dali::BaseHandle arg1 ;
43135   Dali::BaseHandle *argp1 ;
43136   Dali::KeyFrames result;
43137
43138   argp1 = (Dali::BaseHandle *)jarg1;
43139   if (!argp1) {
43140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43141     return 0;
43142   }
43143   arg1 = *argp1;
43144   {
43145     try {
43146       result = Dali::KeyFrames::DownCast(arg1);
43147     } catch (std::out_of_range& e) {
43148       {
43149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43150       };
43151     } catch (std::exception& e) {
43152       {
43153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (Dali::DaliException e) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43158       };
43159     } catch (...) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43162       };
43163     }
43164   }
43165
43166   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43167   return jresult;
43168 }
43169
43170
43171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43172   void * jresult ;
43173   Dali::KeyFrames *result = 0 ;
43174
43175   {
43176     try {
43177       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43178     } catch (std::out_of_range& e) {
43179       {
43180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43181       };
43182     } catch (std::exception& e) {
43183       {
43184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (Dali::DaliException e) {
43187       {
43188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43189       };
43190     } catch (...) {
43191       {
43192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43193       };
43194     }
43195   }
43196
43197   jresult = (void *)result;
43198   return jresult;
43199 }
43200
43201
43202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43203   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43204
43205   arg1 = (Dali::KeyFrames *)jarg1;
43206   {
43207     try {
43208       delete arg1;
43209     } catch (std::out_of_range& e) {
43210       {
43211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43212       };
43213     } catch (std::exception& e) {
43214       {
43215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43216       };
43217     } catch (Dali::DaliException e) {
43218       {
43219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43220       };
43221     } catch (...) {
43222       {
43223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43224       };
43225     }
43226   }
43227
43228 }
43229
43230
43231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43232   void * jresult ;
43233   Dali::KeyFrames *arg1 = 0 ;
43234   Dali::KeyFrames *result = 0 ;
43235
43236   arg1 = (Dali::KeyFrames *)jarg1;
43237   if (!arg1) {
43238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43239     return 0;
43240   }
43241   {
43242     try {
43243       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43244     } catch (std::out_of_range& e) {
43245       {
43246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43247       };
43248     } catch (std::exception& e) {
43249       {
43250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43251       };
43252     } catch (Dali::DaliException e) {
43253       {
43254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43255       };
43256     } catch (...) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43259       };
43260     }
43261   }
43262
43263   jresult = (void *)result;
43264   return jresult;
43265 }
43266
43267
43268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43269   void * jresult ;
43270   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43271   Dali::KeyFrames *arg2 = 0 ;
43272   Dali::KeyFrames *result = 0 ;
43273
43274   arg1 = (Dali::KeyFrames *)jarg1;
43275   arg2 = (Dali::KeyFrames *)jarg2;
43276   if (!arg2) {
43277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43278     return 0;
43279   }
43280   {
43281     try {
43282       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43283     } catch (std::out_of_range& e) {
43284       {
43285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43286       };
43287     } catch (std::exception& e) {
43288       {
43289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43290       };
43291     } catch (Dali::DaliException e) {
43292       {
43293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43294       };
43295     } catch (...) {
43296       {
43297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43298       };
43299     }
43300   }
43301
43302   jresult = (void *)result;
43303   return jresult;
43304 }
43305
43306
43307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43308   int jresult ;
43309   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43310   Dali::Property::Type result;
43311
43312   arg1 = (Dali::KeyFrames *)jarg1;
43313   {
43314     try {
43315       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43316     } catch (std::out_of_range& e) {
43317       {
43318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43319       };
43320     } catch (std::exception& e) {
43321       {
43322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43323       };
43324     } catch (Dali::DaliException e) {
43325       {
43326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43327       };
43328     } catch (...) {
43329       {
43330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43331       };
43332     }
43333   }
43334
43335   jresult = (int)result;
43336   return jresult;
43337 }
43338
43339
43340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43341   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43342   float arg2 ;
43343   Dali::Property::Value arg3 ;
43344   Dali::Property::Value *argp3 ;
43345
43346   arg1 = (Dali::KeyFrames *)jarg1;
43347   arg2 = (float)jarg2;
43348   argp3 = (Dali::Property::Value *)jarg3;
43349   if (!argp3) {
43350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43351     return ;
43352   }
43353   arg3 = *argp3;
43354   {
43355     try {
43356       (arg1)->Add(arg2,arg3);
43357     } catch (std::out_of_range& e) {
43358       {
43359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43360       };
43361     } catch (std::exception& e) {
43362       {
43363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43364       };
43365     } catch (Dali::DaliException e) {
43366       {
43367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43368       };
43369     } catch (...) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43372       };
43373     }
43374   }
43375
43376 }
43377
43378
43379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43380   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43381   float arg2 ;
43382   Dali::Property::Value arg3 ;
43383   Dali::AlphaFunction arg4 ;
43384   Dali::Property::Value *argp3 ;
43385   Dali::AlphaFunction *argp4 ;
43386
43387   arg1 = (Dali::KeyFrames *)jarg1;
43388   arg2 = (float)jarg2;
43389   argp3 = (Dali::Property::Value *)jarg3;
43390   if (!argp3) {
43391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43392     return ;
43393   }
43394   arg3 = *argp3;
43395   argp4 = (Dali::AlphaFunction *)jarg4;
43396   if (!argp4) {
43397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43398     return ;
43399   }
43400   arg4 = *argp4;
43401   {
43402     try {
43403       (arg1)->Add(arg2,arg3,arg4);
43404     } catch (std::out_of_range& e) {
43405       {
43406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43407       };
43408     } catch (std::exception& e) {
43409       {
43410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43411       };
43412     } catch (Dali::DaliException e) {
43413       {
43414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43419       };
43420     }
43421   }
43422
43423 }
43424
43425
43426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43427   int jresult ;
43428   int result;
43429
43430   result = (int)Dali::Path::Property::POINTS;
43431   jresult = (int)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43437   int jresult ;
43438   int result;
43439
43440   result = (int)Dali::Path::Property::CONTROL_POINTS;
43441   jresult = (int)result;
43442   return jresult;
43443 }
43444
43445
43446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43447   void * jresult ;
43448   Dali::Path::Property *result = 0 ;
43449
43450   {
43451     try {
43452       result = (Dali::Path::Property *)new Dali::Path::Property();
43453     } catch (std::out_of_range& e) {
43454       {
43455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43456       };
43457     } catch (std::exception& e) {
43458       {
43459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43460       };
43461     } catch (Dali::DaliException e) {
43462       {
43463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43464       };
43465     } catch (...) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43468       };
43469     }
43470   }
43471
43472   jresult = (void *)result;
43473   return jresult;
43474 }
43475
43476
43477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43478   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43479
43480   arg1 = (Dali::Path::Property *)jarg1;
43481   {
43482     try {
43483       delete arg1;
43484     } catch (std::out_of_range& e) {
43485       {
43486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43487       };
43488     } catch (std::exception& e) {
43489       {
43490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43491       };
43492     } catch (Dali::DaliException e) {
43493       {
43494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43495       };
43496     } catch (...) {
43497       {
43498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43499       };
43500     }
43501   }
43502
43503 }
43504
43505
43506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43507   void * jresult ;
43508   Dali::Path result;
43509
43510   {
43511     try {
43512       result = Dali::Path::New();
43513     } catch (std::out_of_range& e) {
43514       {
43515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43516       };
43517     } catch (std::exception& e) {
43518       {
43519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43520       };
43521     } catch (Dali::DaliException e) {
43522       {
43523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43524       };
43525     } catch (...) {
43526       {
43527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43528       };
43529     }
43530   }
43531
43532   jresult = new Dali::Path((const Dali::Path &)result);
43533   return jresult;
43534 }
43535
43536
43537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43538   void * jresult ;
43539   Dali::BaseHandle arg1 ;
43540   Dali::BaseHandle *argp1 ;
43541   Dali::Path result;
43542
43543   argp1 = (Dali::BaseHandle *)jarg1;
43544   if (!argp1) {
43545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43546     return 0;
43547   }
43548   arg1 = *argp1;
43549   {
43550     try {
43551       result = Dali::Path::DownCast(arg1);
43552     } catch (std::out_of_range& e) {
43553       {
43554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43555       };
43556     } catch (std::exception& e) {
43557       {
43558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43559       };
43560     } catch (Dali::DaliException e) {
43561       {
43562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43563       };
43564     } catch (...) {
43565       {
43566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43567       };
43568     }
43569   }
43570
43571   jresult = new Dali::Path((const Dali::Path &)result);
43572   return jresult;
43573 }
43574
43575
43576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43577   void * jresult ;
43578   Dali::Path *result = 0 ;
43579
43580   {
43581     try {
43582       result = (Dali::Path *)new Dali::Path();
43583     } catch (std::out_of_range& e) {
43584       {
43585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43586       };
43587     } catch (std::exception& e) {
43588       {
43589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43590       };
43591     } catch (Dali::DaliException e) {
43592       {
43593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43594       };
43595     } catch (...) {
43596       {
43597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43598       };
43599     }
43600   }
43601
43602   jresult = (void *)result;
43603   return jresult;
43604 }
43605
43606
43607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43608   Dali::Path *arg1 = (Dali::Path *) 0 ;
43609
43610   arg1 = (Dali::Path *)jarg1;
43611   {
43612     try {
43613       delete arg1;
43614     } catch (std::out_of_range& e) {
43615       {
43616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43617       };
43618     } catch (std::exception& e) {
43619       {
43620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43621       };
43622     } catch (Dali::DaliException e) {
43623       {
43624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43625       };
43626     } catch (...) {
43627       {
43628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43629       };
43630     }
43631   }
43632
43633 }
43634
43635
43636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43637   void * jresult ;
43638   Dali::Path *arg1 = 0 ;
43639   Dali::Path *result = 0 ;
43640
43641   arg1 = (Dali::Path *)jarg1;
43642   if (!arg1) {
43643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43644     return 0;
43645   }
43646   {
43647     try {
43648       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43649     } catch (std::out_of_range& e) {
43650       {
43651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43652       };
43653     } catch (std::exception& e) {
43654       {
43655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43656       };
43657     } catch (Dali::DaliException e) {
43658       {
43659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43660       };
43661     } catch (...) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43664       };
43665     }
43666   }
43667
43668   jresult = (void *)result;
43669   return jresult;
43670 }
43671
43672
43673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43674   void * jresult ;
43675   Dali::Path *arg1 = (Dali::Path *) 0 ;
43676   Dali::Path *arg2 = 0 ;
43677   Dali::Path *result = 0 ;
43678
43679   arg1 = (Dali::Path *)jarg1;
43680   arg2 = (Dali::Path *)jarg2;
43681   if (!arg2) {
43682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43683     return 0;
43684   }
43685   {
43686     try {
43687       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43688     } catch (std::out_of_range& e) {
43689       {
43690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43691       };
43692     } catch (std::exception& e) {
43693       {
43694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43695       };
43696     } catch (Dali::DaliException e) {
43697       {
43698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43699       };
43700     } catch (...) {
43701       {
43702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43703       };
43704     }
43705   }
43706
43707   jresult = (void *)result;
43708   return jresult;
43709 }
43710
43711
43712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43713   Dali::Path *arg1 = (Dali::Path *) 0 ;
43714   Dali::Vector3 *arg2 = 0 ;
43715
43716   arg1 = (Dali::Path *)jarg1;
43717   arg2 = (Dali::Vector3 *)jarg2;
43718   if (!arg2) {
43719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43720     return ;
43721   }
43722   {
43723     try {
43724       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43725     } catch (std::out_of_range& e) {
43726       {
43727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43728       };
43729     } catch (std::exception& e) {
43730       {
43731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43732       };
43733     } catch (Dali::DaliException e) {
43734       {
43735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43736       };
43737     } catch (...) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43740       };
43741     }
43742   }
43743
43744 }
43745
43746
43747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43748   Dali::Path *arg1 = (Dali::Path *) 0 ;
43749   Dali::Vector3 *arg2 = 0 ;
43750
43751   arg1 = (Dali::Path *)jarg1;
43752   arg2 = (Dali::Vector3 *)jarg2;
43753   if (!arg2) {
43754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43755     return ;
43756   }
43757   {
43758     try {
43759       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43760     } catch (std::out_of_range& e) {
43761       {
43762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43763       };
43764     } catch (std::exception& e) {
43765       {
43766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43767       };
43768     } catch (Dali::DaliException e) {
43769       {
43770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43771       };
43772     } catch (...) {
43773       {
43774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43775       };
43776     }
43777   }
43778
43779 }
43780
43781
43782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43783   Dali::Path *arg1 = (Dali::Path *) 0 ;
43784   float arg2 ;
43785
43786   arg1 = (Dali::Path *)jarg1;
43787   arg2 = (float)jarg2;
43788   {
43789     try {
43790       (arg1)->GenerateControlPoints(arg2);
43791     } catch (std::out_of_range& e) {
43792       {
43793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43794       };
43795     } catch (std::exception& e) {
43796       {
43797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43798       };
43799     } catch (Dali::DaliException e) {
43800       {
43801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43802       };
43803     } catch (...) {
43804       {
43805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43806       };
43807     }
43808   }
43809
43810 }
43811
43812
43813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43814   Dali::Path *arg1 = (Dali::Path *) 0 ;
43815   float arg2 ;
43816   Dali::Vector3 *arg3 = 0 ;
43817   Dali::Vector3 *arg4 = 0 ;
43818
43819   arg1 = (Dali::Path *)jarg1;
43820   arg2 = (float)jarg2;
43821   arg3 = (Dali::Vector3 *)jarg3;
43822   if (!arg3) {
43823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43824     return ;
43825   }
43826   arg4 = (Dali::Vector3 *)jarg4;
43827   if (!arg4) {
43828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43829     return ;
43830   }
43831   {
43832     try {
43833       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43834     } catch (std::out_of_range& e) {
43835       {
43836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43837       };
43838     } catch (std::exception& e) {
43839       {
43840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43841       };
43842     } catch (Dali::DaliException e) {
43843       {
43844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43845       };
43846     } catch (...) {
43847       {
43848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43849       };
43850     }
43851   }
43852
43853 }
43854
43855
43856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43857   void * jresult ;
43858   Dali::Path *arg1 = (Dali::Path *) 0 ;
43859   size_t arg2 ;
43860   Dali::Vector3 *result = 0 ;
43861
43862   arg1 = (Dali::Path *)jarg1;
43863   arg2 = (size_t)jarg2;
43864   {
43865     try {
43866       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43867     } catch (std::out_of_range& e) {
43868       {
43869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43870       };
43871     } catch (std::exception& e) {
43872       {
43873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43874       };
43875     } catch (Dali::DaliException e) {
43876       {
43877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43878       };
43879     } catch (...) {
43880       {
43881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43882       };
43883     }
43884   }
43885
43886   jresult = (void *)result;
43887   return jresult;
43888 }
43889
43890
43891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43892   void * jresult ;
43893   Dali::Path *arg1 = (Dali::Path *) 0 ;
43894   size_t arg2 ;
43895   Dali::Vector3 *result = 0 ;
43896
43897   arg1 = (Dali::Path *)jarg1;
43898   arg2 = (size_t)jarg2;
43899   {
43900     try {
43901       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43902     } catch (std::out_of_range& e) {
43903       {
43904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43905       };
43906     } catch (std::exception& e) {
43907       {
43908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43909       };
43910     } catch (Dali::DaliException e) {
43911       {
43912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43913       };
43914     } catch (...) {
43915       {
43916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43917       };
43918     }
43919   }
43920
43921   jresult = (void *)result;
43922   return jresult;
43923 }
43924
43925
43926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43927   unsigned long jresult ;
43928   Dali::Path *arg1 = (Dali::Path *) 0 ;
43929   size_t result;
43930
43931   arg1 = (Dali::Path *)jarg1;
43932   {
43933     try {
43934       result = ((Dali::Path const *)arg1)->GetPointCount();
43935     } catch (std::out_of_range& e) {
43936       {
43937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43938       };
43939     } catch (std::exception& e) {
43940       {
43941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (Dali::DaliException e) {
43944       {
43945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43946       };
43947     } catch (...) {
43948       {
43949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43950       };
43951     }
43952   }
43953
43954   jresult = (unsigned long)result;
43955   return jresult;
43956 }
43957
43958
43959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43960   void * jresult ;
43961   float arg1 ;
43962   Dali::TimePeriod *result = 0 ;
43963
43964   arg1 = (float)jarg1;
43965   {
43966     try {
43967       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43968     } catch (std::out_of_range& e) {
43969       {
43970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43971       };
43972     } catch (std::exception& e) {
43973       {
43974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43975       };
43976     } catch (Dali::DaliException e) {
43977       {
43978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43979       };
43980     } catch (...) {
43981       {
43982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43983       };
43984     }
43985   }
43986
43987   jresult = (void *)result;
43988   return jresult;
43989 }
43990
43991
43992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43993   void * jresult ;
43994   float arg1 ;
43995   float arg2 ;
43996   Dali::TimePeriod *result = 0 ;
43997
43998   arg1 = (float)jarg1;
43999   arg2 = (float)jarg2;
44000   {
44001     try {
44002       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44003     } catch (std::out_of_range& e) {
44004       {
44005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44006       };
44007     } catch (std::exception& e) {
44008       {
44009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44010       };
44011     } catch (Dali::DaliException e) {
44012       {
44013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44018       };
44019     }
44020   }
44021
44022   jresult = (void *)result;
44023   return jresult;
44024 }
44025
44026
44027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44028   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44029
44030   arg1 = (Dali::TimePeriod *)jarg1;
44031   {
44032     try {
44033       delete arg1;
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (Dali::DaliException e) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44045       };
44046     } catch (...) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44049       };
44050     }
44051   }
44052
44053 }
44054
44055
44056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44057   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44058   float arg2 ;
44059
44060   arg1 = (Dali::TimePeriod *)jarg1;
44061   arg2 = (float)jarg2;
44062   if (arg1) (arg1)->delaySeconds = arg2;
44063 }
44064
44065
44066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44067   float jresult ;
44068   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44069   float result;
44070
44071   arg1 = (Dali::TimePeriod *)jarg1;
44072   result = (float) ((arg1)->delaySeconds);
44073   jresult = result;
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44079   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44080   float arg2 ;
44081
44082   arg1 = (Dali::TimePeriod *)jarg1;
44083   arg2 = (float)jarg2;
44084   if (arg1) (arg1)->durationSeconds = arg2;
44085 }
44086
44087
44088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44089   float jresult ;
44090   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44091   float result;
44092
44093   arg1 = (Dali::TimePeriod *)jarg1;
44094   result = (float) ((arg1)->durationSeconds);
44095   jresult = result;
44096   return jresult;
44097 }
44098
44099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44100   int jresult ;
44101   int result;
44102
44103   result = (int)Dali::LinearConstrainer::Property::VALUE;
44104   jresult = (int)result;
44105   return jresult;
44106 }
44107
44108
44109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44110   int jresult ;
44111   int result;
44112
44113   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44114   jresult = (int)result;
44115   return jresult;
44116 }
44117
44118
44119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44120   void * jresult ;
44121   Dali::LinearConstrainer::Property *result = 0 ;
44122
44123   {
44124     try {
44125       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44126     } catch (std::out_of_range& e) {
44127       {
44128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44129       };
44130     } catch (std::exception& e) {
44131       {
44132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44133       };
44134     } catch (Dali::DaliException e) {
44135       {
44136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44137       };
44138     } catch (...) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44141       };
44142     }
44143   }
44144
44145   jresult = (void *)result;
44146   return jresult;
44147 }
44148
44149
44150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44151   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44152
44153   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44154   {
44155     try {
44156       delete arg1;
44157     } catch (std::out_of_range& e) {
44158       {
44159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44160       };
44161     } catch (std::exception& e) {
44162       {
44163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44164       };
44165     } catch (Dali::DaliException e) {
44166       {
44167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44168       };
44169     } catch (...) {
44170       {
44171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44172       };
44173     }
44174   }
44175
44176 }
44177
44178
44179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44180   void * jresult ;
44181   Dali::LinearConstrainer result;
44182
44183   {
44184     try {
44185       result = Dali::LinearConstrainer::New();
44186     } catch (std::out_of_range& e) {
44187       {
44188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44189       };
44190     } catch (std::exception& e) {
44191       {
44192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44193       };
44194     } catch (Dali::DaliException e) {
44195       {
44196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44197       };
44198     } catch (...) {
44199       {
44200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44201       };
44202     }
44203   }
44204
44205   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44206   return jresult;
44207 }
44208
44209
44210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44211   void * jresult ;
44212   Dali::BaseHandle arg1 ;
44213   Dali::BaseHandle *argp1 ;
44214   Dali::LinearConstrainer result;
44215
44216   argp1 = (Dali::BaseHandle *)jarg1;
44217   if (!argp1) {
44218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44219     return 0;
44220   }
44221   arg1 = *argp1;
44222   {
44223     try {
44224       result = Dali::LinearConstrainer::DownCast(arg1);
44225     } catch (std::out_of_range& e) {
44226       {
44227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44228       };
44229     } catch (std::exception& e) {
44230       {
44231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44232       };
44233     } catch (Dali::DaliException e) {
44234       {
44235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44236       };
44237     } catch (...) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44240       };
44241     }
44242   }
44243
44244   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44245   return jresult;
44246 }
44247
44248
44249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44250   void * jresult ;
44251   Dali::LinearConstrainer *result = 0 ;
44252
44253   {
44254     try {
44255       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44256     } catch (std::out_of_range& e) {
44257       {
44258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44259       };
44260     } catch (std::exception& e) {
44261       {
44262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44263       };
44264     } catch (Dali::DaliException e) {
44265       {
44266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44267       };
44268     } catch (...) {
44269       {
44270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44271       };
44272     }
44273   }
44274
44275   jresult = (void *)result;
44276   return jresult;
44277 }
44278
44279
44280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44281   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44282
44283   arg1 = (Dali::LinearConstrainer *)jarg1;
44284   {
44285     try {
44286       delete arg1;
44287     } catch (std::out_of_range& e) {
44288       {
44289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44290       };
44291     } catch (std::exception& e) {
44292       {
44293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (Dali::DaliException e) {
44296       {
44297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44298       };
44299     } catch (...) {
44300       {
44301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44302       };
44303     }
44304   }
44305
44306 }
44307
44308
44309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44310   void * jresult ;
44311   Dali::LinearConstrainer *arg1 = 0 ;
44312   Dali::LinearConstrainer *result = 0 ;
44313
44314   arg1 = (Dali::LinearConstrainer *)jarg1;
44315   if (!arg1) {
44316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44317     return 0;
44318   }
44319   {
44320     try {
44321       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44322     } catch (std::out_of_range& e) {
44323       {
44324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44325       };
44326     } catch (std::exception& e) {
44327       {
44328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44329       };
44330     } catch (Dali::DaliException e) {
44331       {
44332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44333       };
44334     } catch (...) {
44335       {
44336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44337       };
44338     }
44339   }
44340
44341   jresult = (void *)result;
44342   return jresult;
44343 }
44344
44345
44346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44347   void * jresult ;
44348   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44349   Dali::LinearConstrainer *arg2 = 0 ;
44350   Dali::LinearConstrainer *result = 0 ;
44351
44352   arg1 = (Dali::LinearConstrainer *)jarg1;
44353   arg2 = (Dali::LinearConstrainer *)jarg2;
44354   if (!arg2) {
44355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44356     return 0;
44357   }
44358   {
44359     try {
44360       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44361     } catch (std::out_of_range& e) {
44362       {
44363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44364       };
44365     } catch (std::exception& e) {
44366       {
44367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44368       };
44369     } catch (Dali::DaliException e) {
44370       {
44371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44372       };
44373     } catch (...) {
44374       {
44375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44376       };
44377     }
44378   }
44379
44380   jresult = (void *)result;
44381   return jresult;
44382 }
44383
44384
44385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44386   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44387   SwigValueWrapper< Dali::Property > arg2 ;
44388   SwigValueWrapper< Dali::Property > arg3 ;
44389   Dali::Vector2 *arg4 = 0 ;
44390   Dali::Vector2 *arg5 = 0 ;
44391   Dali::Property *argp2 ;
44392   Dali::Property *argp3 ;
44393
44394   arg1 = (Dali::LinearConstrainer *)jarg1;
44395   argp2 = (Dali::Property *)jarg2;
44396   if (!argp2) {
44397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44398     return ;
44399   }
44400   arg2 = *argp2;
44401   argp3 = (Dali::Property *)jarg3;
44402   if (!argp3) {
44403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44404     return ;
44405   }
44406   arg3 = *argp3;
44407   arg4 = (Dali::Vector2 *)jarg4;
44408   if (!arg4) {
44409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44410     return ;
44411   }
44412   arg5 = (Dali::Vector2 *)jarg5;
44413   if (!arg5) {
44414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44415     return ;
44416   }
44417   {
44418     try {
44419       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44420     } catch (std::out_of_range& e) {
44421       {
44422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44423       };
44424     } catch (std::exception& e) {
44425       {
44426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44427       };
44428     } catch (Dali::DaliException e) {
44429       {
44430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44431       };
44432     } catch (...) {
44433       {
44434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44435       };
44436     }
44437   }
44438
44439 }
44440
44441
44442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44443   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44444   SwigValueWrapper< Dali::Property > arg2 ;
44445   SwigValueWrapper< Dali::Property > arg3 ;
44446   Dali::Vector2 *arg4 = 0 ;
44447   Dali::Property *argp2 ;
44448   Dali::Property *argp3 ;
44449
44450   arg1 = (Dali::LinearConstrainer *)jarg1;
44451   argp2 = (Dali::Property *)jarg2;
44452   if (!argp2) {
44453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44454     return ;
44455   }
44456   arg2 = *argp2;
44457   argp3 = (Dali::Property *)jarg3;
44458   if (!argp3) {
44459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44460     return ;
44461   }
44462   arg3 = *argp3;
44463   arg4 = (Dali::Vector2 *)jarg4;
44464   if (!arg4) {
44465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44466     return ;
44467   }
44468   {
44469     try {
44470       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44471     } catch (std::out_of_range& e) {
44472       {
44473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44474       };
44475     } catch (std::exception& e) {
44476       {
44477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44478       };
44479     } catch (Dali::DaliException e) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44482       };
44483     } catch (...) {
44484       {
44485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44486       };
44487     }
44488   }
44489
44490 }
44491
44492
44493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44494   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44495   Dali::Handle *arg2 = 0 ;
44496
44497   arg1 = (Dali::LinearConstrainer *)jarg1;
44498   arg2 = (Dali::Handle *)jarg2;
44499   if (!arg2) {
44500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44501     return ;
44502   }
44503   {
44504     try {
44505       (arg1)->Remove(*arg2);
44506     } catch (std::out_of_range& e) {
44507       {
44508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44509       };
44510     } catch (std::exception& e) {
44511       {
44512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44513       };
44514     } catch (Dali::DaliException e) {
44515       {
44516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44517       };
44518     } catch (...) {
44519       {
44520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44521       };
44522     }
44523   }
44524
44525 }
44526
44527
44528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44529   int jresult ;
44530   int result;
44531
44532   result = (int)Dali::PathConstrainer::Property::FORWARD;
44533   jresult = (int)result;
44534   return jresult;
44535 }
44536
44537
44538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44539   int jresult ;
44540   int result;
44541
44542   result = (int)Dali::PathConstrainer::Property::POINTS;
44543   jresult = (int)result;
44544   return jresult;
44545 }
44546
44547
44548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44549   int jresult ;
44550   int result;
44551
44552   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44553   jresult = (int)result;
44554   return jresult;
44555 }
44556
44557
44558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44559   void * jresult ;
44560   Dali::PathConstrainer::Property *result = 0 ;
44561
44562   {
44563     try {
44564       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44565     } catch (std::out_of_range& e) {
44566       {
44567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44568       };
44569     } catch (std::exception& e) {
44570       {
44571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44572       };
44573     } catch (Dali::DaliException e) {
44574       {
44575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44576       };
44577     } catch (...) {
44578       {
44579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44580       };
44581     }
44582   }
44583
44584   jresult = (void *)result;
44585   return jresult;
44586 }
44587
44588
44589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44590   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44591
44592   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44593   {
44594     try {
44595       delete arg1;
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44603       };
44604     } catch (Dali::DaliException e) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44607       };
44608     } catch (...) {
44609       {
44610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44611       };
44612     }
44613   }
44614
44615 }
44616
44617
44618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44619   void * jresult ;
44620   Dali::PathConstrainer result;
44621
44622   {
44623     try {
44624       result = Dali::PathConstrainer::New();
44625     } catch (std::out_of_range& e) {
44626       {
44627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44628       };
44629     } catch (std::exception& e) {
44630       {
44631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44632       };
44633     } catch (Dali::DaliException e) {
44634       {
44635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44636       };
44637     } catch (...) {
44638       {
44639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44640       };
44641     }
44642   }
44643
44644   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44645   return jresult;
44646 }
44647
44648
44649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44650   void * jresult ;
44651   Dali::BaseHandle arg1 ;
44652   Dali::BaseHandle *argp1 ;
44653   Dali::PathConstrainer result;
44654
44655   argp1 = (Dali::BaseHandle *)jarg1;
44656   if (!argp1) {
44657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44658     return 0;
44659   }
44660   arg1 = *argp1;
44661   {
44662     try {
44663       result = Dali::PathConstrainer::DownCast(arg1);
44664     } catch (std::out_of_range& e) {
44665       {
44666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44667       };
44668     } catch (std::exception& e) {
44669       {
44670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44671       };
44672     } catch (Dali::DaliException e) {
44673       {
44674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44675       };
44676     } catch (...) {
44677       {
44678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44679       };
44680     }
44681   }
44682
44683   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44684   return jresult;
44685 }
44686
44687
44688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44689   void * jresult ;
44690   Dali::PathConstrainer *result = 0 ;
44691
44692   {
44693     try {
44694       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44695     } catch (std::out_of_range& e) {
44696       {
44697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44698       };
44699     } catch (std::exception& e) {
44700       {
44701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44702       };
44703     } catch (Dali::DaliException e) {
44704       {
44705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44710       };
44711     }
44712   }
44713
44714   jresult = (void *)result;
44715   return jresult;
44716 }
44717
44718
44719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44720   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44721
44722   arg1 = (Dali::PathConstrainer *)jarg1;
44723   {
44724     try {
44725       delete arg1;
44726     } catch (std::out_of_range& e) {
44727       {
44728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44729       };
44730     } catch (std::exception& e) {
44731       {
44732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44733       };
44734     } catch (Dali::DaliException e) {
44735       {
44736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44737       };
44738     } catch (...) {
44739       {
44740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44741       };
44742     }
44743   }
44744
44745 }
44746
44747
44748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44749   void * jresult ;
44750   Dali::PathConstrainer *arg1 = 0 ;
44751   Dali::PathConstrainer *result = 0 ;
44752
44753   arg1 = (Dali::PathConstrainer *)jarg1;
44754   if (!arg1) {
44755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44756     return 0;
44757   }
44758   {
44759     try {
44760       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44761     } catch (std::out_of_range& e) {
44762       {
44763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44764       };
44765     } catch (std::exception& e) {
44766       {
44767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44768       };
44769     } catch (Dali::DaliException e) {
44770       {
44771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44772       };
44773     } catch (...) {
44774       {
44775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44776       };
44777     }
44778   }
44779
44780   jresult = (void *)result;
44781   return jresult;
44782 }
44783
44784
44785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44786   void * jresult ;
44787   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44788   Dali::PathConstrainer *arg2 = 0 ;
44789   Dali::PathConstrainer *result = 0 ;
44790
44791   arg1 = (Dali::PathConstrainer *)jarg1;
44792   arg2 = (Dali::PathConstrainer *)jarg2;
44793   if (!arg2) {
44794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44795     return 0;
44796   }
44797   {
44798     try {
44799       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44800     } catch (std::out_of_range& e) {
44801       {
44802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44803       };
44804     } catch (std::exception& e) {
44805       {
44806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44807       };
44808     } catch (Dali::DaliException e) {
44809       {
44810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44811       };
44812     } catch (...) {
44813       {
44814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44815       };
44816     }
44817   }
44818
44819   jresult = (void *)result;
44820   return jresult;
44821 }
44822
44823
44824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44825   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44826   SwigValueWrapper< Dali::Property > arg2 ;
44827   SwigValueWrapper< Dali::Property > arg3 ;
44828   Dali::Vector2 *arg4 = 0 ;
44829   Dali::Vector2 *arg5 = 0 ;
44830   Dali::Property *argp2 ;
44831   Dali::Property *argp3 ;
44832
44833   arg1 = (Dali::PathConstrainer *)jarg1;
44834   argp2 = (Dali::Property *)jarg2;
44835   if (!argp2) {
44836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44837     return ;
44838   }
44839   arg2 = *argp2;
44840   argp3 = (Dali::Property *)jarg3;
44841   if (!argp3) {
44842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44843     return ;
44844   }
44845   arg3 = *argp3;
44846   arg4 = (Dali::Vector2 *)jarg4;
44847   if (!arg4) {
44848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44849     return ;
44850   }
44851   arg5 = (Dali::Vector2 *)jarg5;
44852   if (!arg5) {
44853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44854     return ;
44855   }
44856   {
44857     try {
44858       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44859     } catch (std::out_of_range& e) {
44860       {
44861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44862       };
44863     } catch (std::exception& e) {
44864       {
44865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44866       };
44867     } catch (Dali::DaliException e) {
44868       {
44869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44870       };
44871     } catch (...) {
44872       {
44873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44874       };
44875     }
44876   }
44877
44878 }
44879
44880
44881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44882   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44883   SwigValueWrapper< Dali::Property > arg2 ;
44884   SwigValueWrapper< Dali::Property > arg3 ;
44885   Dali::Vector2 *arg4 = 0 ;
44886   Dali::Property *argp2 ;
44887   Dali::Property *argp3 ;
44888
44889   arg1 = (Dali::PathConstrainer *)jarg1;
44890   argp2 = (Dali::Property *)jarg2;
44891   if (!argp2) {
44892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44893     return ;
44894   }
44895   arg2 = *argp2;
44896   argp3 = (Dali::Property *)jarg3;
44897   if (!argp3) {
44898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44899     return ;
44900   }
44901   arg3 = *argp3;
44902   arg4 = (Dali::Vector2 *)jarg4;
44903   if (!arg4) {
44904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44905     return ;
44906   }
44907   {
44908     try {
44909       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44910     } catch (std::out_of_range& e) {
44911       {
44912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44913       };
44914     } catch (std::exception& e) {
44915       {
44916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44917       };
44918     } catch (Dali::DaliException e) {
44919       {
44920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44921       };
44922     } catch (...) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44925       };
44926     }
44927   }
44928
44929 }
44930
44931
44932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44933   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44934   Dali::Handle *arg2 = 0 ;
44935
44936   arg1 = (Dali::PathConstrainer *)jarg1;
44937   arg2 = (Dali::Handle *)jarg2;
44938   if (!arg2) {
44939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44940     return ;
44941   }
44942   {
44943     try {
44944       (arg1)->Remove(*arg2);
44945     } catch (std::out_of_range& e) {
44946       {
44947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44948       };
44949     } catch (std::exception& e) {
44950       {
44951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (Dali::DaliException e) {
44954       {
44955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44956       };
44957     } catch (...) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44960       };
44961     }
44962   }
44963
44964 }
44965
44966
44967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44968   int jresult ;
44969   Dali::FittingMode::Type result;
44970
44971   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44972   jresult = (int)result;
44973   return jresult;
44974 }
44975
44976
44977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44978   int jresult ;
44979   Dali::SamplingMode::Type result;
44980
44981   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44982   jresult = (int)result;
44983   return jresult;
44984 }
44985
44986
44987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44988   void * jresult ;
44989   Dali::BufferImage *result = 0 ;
44990
44991   {
44992     try {
44993       result = (Dali::BufferImage *)new Dali::BufferImage();
44994     } catch (std::out_of_range& e) {
44995       {
44996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44997       };
44998     } catch (std::exception& e) {
44999       {
45000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45001       };
45002     } catch (Dali::DaliException e) {
45003       {
45004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45005       };
45006     } catch (...) {
45007       {
45008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45009       };
45010     }
45011   }
45012
45013   jresult = (void *)result;
45014   return jresult;
45015 }
45016
45017
45018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45019   void * jresult ;
45020   unsigned int arg1 ;
45021   unsigned int arg2 ;
45022   Dali::Pixel::Format arg3 ;
45023   Dali::BufferImage result;
45024
45025   arg1 = (unsigned int)jarg1;
45026   arg2 = (unsigned int)jarg2;
45027   arg3 = (Dali::Pixel::Format)jarg3;
45028   {
45029     try {
45030       result = Dali::BufferImage::New(arg1,arg2,arg3);
45031     } catch (std::out_of_range& e) {
45032       {
45033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45034       };
45035     } catch (std::exception& e) {
45036       {
45037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45038       };
45039     } catch (Dali::DaliException e) {
45040       {
45041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45042       };
45043     } catch (...) {
45044       {
45045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45046       };
45047     }
45048   }
45049
45050   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45051   return jresult;
45052 }
45053
45054
45055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45056   void * jresult ;
45057   unsigned int arg1 ;
45058   unsigned int arg2 ;
45059   Dali::BufferImage result;
45060
45061   arg1 = (unsigned int)jarg1;
45062   arg2 = (unsigned int)jarg2;
45063   {
45064     try {
45065       result = Dali::BufferImage::New(arg1,arg2);
45066     } catch (std::out_of_range& e) {
45067       {
45068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45069       };
45070     } catch (std::exception& e) {
45071       {
45072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45073       };
45074     } catch (Dali::DaliException e) {
45075       {
45076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45077       };
45078     } catch (...) {
45079       {
45080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45081       };
45082     }
45083   }
45084
45085   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45086   return jresult;
45087 }
45088
45089
45090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45091   void * jresult ;
45092   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45093   unsigned int arg2 ;
45094   unsigned int arg3 ;
45095   Dali::Pixel::Format arg4 ;
45096   unsigned int arg5 ;
45097   Dali::BufferImage result;
45098
45099   arg1 = jarg1;
45100   arg2 = (unsigned int)jarg2;
45101   arg3 = (unsigned int)jarg3;
45102   arg4 = (Dali::Pixel::Format)jarg4;
45103   arg5 = (unsigned int)jarg5;
45104   {
45105     try {
45106       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45107     } catch (std::out_of_range& e) {
45108       {
45109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (std::exception& e) {
45112       {
45113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45114       };
45115     } catch (Dali::DaliException e) {
45116       {
45117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45118       };
45119     } catch (...) {
45120       {
45121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45122       };
45123     }
45124   }
45125
45126   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45127
45128
45129   return jresult;
45130 }
45131
45132
45133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45134   void * jresult ;
45135   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45136   unsigned int arg2 ;
45137   unsigned int arg3 ;
45138   Dali::Pixel::Format arg4 ;
45139   Dali::BufferImage result;
45140
45141   arg1 = jarg1;
45142   arg2 = (unsigned int)jarg2;
45143   arg3 = (unsigned int)jarg3;
45144   arg4 = (Dali::Pixel::Format)jarg4;
45145   {
45146     try {
45147       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45148     } catch (std::out_of_range& e) {
45149       {
45150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45151       };
45152     } catch (std::exception& e) {
45153       {
45154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45155       };
45156     } catch (Dali::DaliException e) {
45157       {
45158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45159       };
45160     } catch (...) {
45161       {
45162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45163       };
45164     }
45165   }
45166
45167   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45168
45169
45170   return jresult;
45171 }
45172
45173
45174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45175   void * jresult ;
45176   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45177   unsigned int arg2 ;
45178   unsigned int arg3 ;
45179   Dali::BufferImage result;
45180
45181   arg1 = jarg1;
45182   arg2 = (unsigned int)jarg2;
45183   arg3 = (unsigned int)jarg3;
45184   {
45185     try {
45186       result = Dali::BufferImage::New(arg1,arg2,arg3);
45187     } catch (std::out_of_range& e) {
45188       {
45189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45190       };
45191     } catch (std::exception& e) {
45192       {
45193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45194       };
45195     } catch (Dali::DaliException e) {
45196       {
45197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45198       };
45199     } catch (...) {
45200       {
45201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45202       };
45203     }
45204   }
45205
45206   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45207
45208
45209   return jresult;
45210 }
45211
45212
45213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45214   void * jresult ;
45215   Dali::BaseHandle arg1 ;
45216   Dali::BaseHandle *argp1 ;
45217   Dali::BufferImage result;
45218
45219   argp1 = (Dali::BaseHandle *)jarg1;
45220   if (!argp1) {
45221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45222     return 0;
45223   }
45224   arg1 = *argp1;
45225   {
45226     try {
45227       result = Dali::BufferImage::DownCast(arg1);
45228     } catch (std::out_of_range& e) {
45229       {
45230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45231       };
45232     } catch (std::exception& e) {
45233       {
45234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (Dali::DaliException e) {
45237       {
45238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45239       };
45240     } catch (...) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45243       };
45244     }
45245   }
45246
45247   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45248   return jresult;
45249 }
45250
45251
45252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45253   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45254
45255   arg1 = (Dali::BufferImage *)jarg1;
45256   {
45257     try {
45258       delete arg1;
45259     } catch (std::out_of_range& e) {
45260       {
45261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45262       };
45263     } catch (std::exception& e) {
45264       {
45265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45266       };
45267     } catch (Dali::DaliException e) {
45268       {
45269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45270       };
45271     } catch (...) {
45272       {
45273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45274       };
45275     }
45276   }
45277
45278 }
45279
45280
45281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45282   void * jresult ;
45283   Dali::BufferImage *arg1 = 0 ;
45284   Dali::BufferImage *result = 0 ;
45285
45286   arg1 = (Dali::BufferImage *)jarg1;
45287   if (!arg1) {
45288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45289     return 0;
45290   }
45291   {
45292     try {
45293       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45294     } catch (std::out_of_range& e) {
45295       {
45296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45297       };
45298     } catch (std::exception& e) {
45299       {
45300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45301       };
45302     } catch (Dali::DaliException e) {
45303       {
45304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45305       };
45306     } catch (...) {
45307       {
45308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45309       };
45310     }
45311   }
45312
45313   jresult = (void *)result;
45314   return jresult;
45315 }
45316
45317
45318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45319   void * jresult ;
45320   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45321   Dali::BufferImage *arg2 = 0 ;
45322   Dali::BufferImage *result = 0 ;
45323
45324   arg1 = (Dali::BufferImage *)jarg1;
45325   arg2 = (Dali::BufferImage *)jarg2;
45326   if (!arg2) {
45327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45328     return 0;
45329   }
45330   {
45331     try {
45332       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45333     } catch (std::out_of_range& e) {
45334       {
45335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45336       };
45337     } catch (std::exception& e) {
45338       {
45339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45340       };
45341     } catch (Dali::DaliException e) {
45342       {
45343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45344       };
45345     } catch (...) {
45346       {
45347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45348       };
45349     }
45350   }
45351
45352   jresult = (void *)result;
45353   return jresult;
45354 }
45355
45356
45357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45358   void * jresult ;
45359   Dali::BufferImage result;
45360
45361   {
45362     try {
45363       result = Dali::BufferImage::WHITE();
45364     } catch (std::out_of_range& e) {
45365       {
45366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45367       };
45368     } catch (std::exception& e) {
45369       {
45370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45371       };
45372     } catch (Dali::DaliException e) {
45373       {
45374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45375       };
45376     } catch (...) {
45377       {
45378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45379       };
45380     }
45381   }
45382
45383   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45384   return jresult;
45385 }
45386
45387
45388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45389   void * jresult ;
45390   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45391   Dali::PixelBuffer *result = 0 ;
45392
45393   arg1 = (Dali::BufferImage *)jarg1;
45394   {
45395     try {
45396       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45397     } catch (std::out_of_range& e) {
45398       {
45399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45400       };
45401     } catch (std::exception& e) {
45402       {
45403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45404       };
45405     } catch (Dali::DaliException e) {
45406       {
45407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45408       };
45409     } catch (...) {
45410       {
45411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45412       };
45413     }
45414   }
45415
45416   jresult = (void *)result;
45417   return jresult;
45418 }
45419
45420
45421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45422   unsigned int jresult ;
45423   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45424   unsigned int result;
45425
45426   arg1 = (Dali::BufferImage *)jarg1;
45427   {
45428     try {
45429       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45430     } catch (std::out_of_range& e) {
45431       {
45432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45433       };
45434     } catch (std::exception& e) {
45435       {
45436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (Dali::DaliException e) {
45439       {
45440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45441       };
45442     } catch (...) {
45443       {
45444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45445       };
45446     }
45447   }
45448
45449   jresult = result;
45450   return jresult;
45451 }
45452
45453
45454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45455   unsigned int jresult ;
45456   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45457   unsigned int result;
45458
45459   arg1 = (Dali::BufferImage *)jarg1;
45460   {
45461     try {
45462       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45463     } catch (std::out_of_range& e) {
45464       {
45465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45466       };
45467     } catch (std::exception& e) {
45468       {
45469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45470       };
45471     } catch (Dali::DaliException e) {
45472       {
45473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45474       };
45475     } catch (...) {
45476       {
45477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45478       };
45479     }
45480   }
45481
45482   jresult = result;
45483   return jresult;
45484 }
45485
45486
45487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45488   int jresult ;
45489   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45490   Dali::Pixel::Format result;
45491
45492   arg1 = (Dali::BufferImage *)jarg1;
45493   {
45494     try {
45495       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45496     } catch (std::out_of_range& e) {
45497       {
45498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45499       };
45500     } catch (std::exception& e) {
45501       {
45502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45503       };
45504     } catch (Dali::DaliException e) {
45505       {
45506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45507       };
45508     } catch (...) {
45509       {
45510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45511       };
45512     }
45513   }
45514
45515   jresult = (int)result;
45516   return jresult;
45517 }
45518
45519
45520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45521   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45522
45523   arg1 = (Dali::BufferImage *)jarg1;
45524   {
45525     try {
45526       (arg1)->Update();
45527     } catch (std::out_of_range& e) {
45528       {
45529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45530       };
45531     } catch (std::exception& e) {
45532       {
45533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45534       };
45535     } catch (Dali::DaliException e) {
45536       {
45537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45538       };
45539     } catch (...) {
45540       {
45541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45542       };
45543     }
45544   }
45545
45546 }
45547
45548
45549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45550   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45551   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45552   Dali::RectArea *argp2 ;
45553
45554   arg1 = (Dali::BufferImage *)jarg1;
45555   argp2 = (Dali::RectArea *)jarg2;
45556   if (!argp2) {
45557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45558     return ;
45559   }
45560   arg2 = *argp2;
45561   {
45562     try {
45563       (arg1)->Update(arg2);
45564     } catch (std::out_of_range& e) {
45565       {
45566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45567       };
45568     } catch (std::exception& e) {
45569       {
45570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45571       };
45572     } catch (Dali::DaliException e) {
45573       {
45574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45575       };
45576     } catch (...) {
45577       {
45578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45579       };
45580     }
45581   }
45582
45583 }
45584
45585
45586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45587   unsigned int jresult ;
45588   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45589   bool result;
45590
45591   arg1 = (Dali::BufferImage *)jarg1;
45592   {
45593     try {
45594       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45595     } catch (std::out_of_range& e) {
45596       {
45597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45598       };
45599     } catch (std::exception& e) {
45600       {
45601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (Dali::DaliException e) {
45604       {
45605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45606       };
45607     } catch (...) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45610       };
45611     }
45612   }
45613
45614   jresult = result;
45615   return jresult;
45616 }
45617
45618
45619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45620   void * jresult ;
45621   Dali::EncodedBufferImage *result = 0 ;
45622
45623   {
45624     try {
45625       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45626     } catch (std::out_of_range& e) {
45627       {
45628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45629       };
45630     } catch (std::exception& e) {
45631       {
45632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (Dali::DaliException e) {
45635       {
45636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45637       };
45638     } catch (...) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45641       };
45642     }
45643   }
45644
45645   jresult = (void *)result;
45646   return jresult;
45647 }
45648
45649
45650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45651   void * jresult ;
45652   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45653   std::size_t arg2 ;
45654   Dali::EncodedBufferImage result;
45655
45656   arg1 = (uint8_t *)jarg1;
45657   arg2 = (std::size_t)jarg2;
45658   {
45659     try {
45660       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45661     } catch (std::out_of_range& e) {
45662       {
45663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45664       };
45665     } catch (std::exception& e) {
45666       {
45667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (Dali::DaliException e) {
45670       {
45671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679
45680   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45681   return jresult;
45682 }
45683
45684
45685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45686   void * jresult ;
45687   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45688   std::size_t arg2 ;
45689   Dali::ImageDimensions arg3 ;
45690   Dali::FittingMode::Type arg4 ;
45691   Dali::SamplingMode::Type arg5 ;
45692   bool arg6 ;
45693   Dali::ImageDimensions *argp3 ;
45694   Dali::EncodedBufferImage result;
45695
45696   arg1 = (uint8_t *)jarg1;
45697   arg2 = (std::size_t)jarg2;
45698   argp3 = (Dali::ImageDimensions *)jarg3;
45699   if (!argp3) {
45700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45701     return 0;
45702   }
45703   arg3 = *argp3;
45704   arg4 = (Dali::FittingMode::Type)jarg4;
45705   arg5 = (Dali::SamplingMode::Type)jarg5;
45706   arg6 = jarg6 ? true : false;
45707   {
45708     try {
45709       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45710     } catch (std::out_of_range& e) {
45711       {
45712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45713       };
45714     } catch (std::exception& e) {
45715       {
45716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45717       };
45718     } catch (Dali::DaliException e) {
45719       {
45720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45721       };
45722     } catch (...) {
45723       {
45724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45725       };
45726     }
45727   }
45728
45729   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45730   return jresult;
45731 }
45732
45733
45734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45735   void * jresult ;
45736   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45737   std::size_t arg2 ;
45738   Dali::ImageDimensions arg3 ;
45739   Dali::FittingMode::Type arg4 ;
45740   Dali::SamplingMode::Type arg5 ;
45741   Dali::ImageDimensions *argp3 ;
45742   Dali::EncodedBufferImage result;
45743
45744   arg1 = (uint8_t *)jarg1;
45745   arg2 = (std::size_t)jarg2;
45746   argp3 = (Dali::ImageDimensions *)jarg3;
45747   if (!argp3) {
45748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45749     return 0;
45750   }
45751   arg3 = *argp3;
45752   arg4 = (Dali::FittingMode::Type)jarg4;
45753   arg5 = (Dali::SamplingMode::Type)jarg5;
45754   {
45755     try {
45756       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45757     } catch (std::out_of_range& e) {
45758       {
45759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45760       };
45761     } catch (std::exception& e) {
45762       {
45763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (Dali::DaliException e) {
45766       {
45767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45768       };
45769     } catch (...) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45772       };
45773     }
45774   }
45775
45776   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45777   return jresult;
45778 }
45779
45780
45781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45782   void * jresult ;
45783   Dali::BaseHandle arg1 ;
45784   Dali::BaseHandle *argp1 ;
45785   Dali::EncodedBufferImage result;
45786
45787   argp1 = (Dali::BaseHandle *)jarg1;
45788   if (!argp1) {
45789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45790     return 0;
45791   }
45792   arg1 = *argp1;
45793   {
45794     try {
45795       result = Dali::EncodedBufferImage::DownCast(arg1);
45796     } catch (std::out_of_range& e) {
45797       {
45798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45799       };
45800     } catch (std::exception& e) {
45801       {
45802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (Dali::DaliException e) {
45805       {
45806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45807       };
45808     } catch (...) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45811       };
45812     }
45813   }
45814
45815   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45816   return jresult;
45817 }
45818
45819
45820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45821   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45822
45823   arg1 = (Dali::EncodedBufferImage *)jarg1;
45824   {
45825     try {
45826       delete arg1;
45827     } catch (std::out_of_range& e) {
45828       {
45829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45830       };
45831     } catch (std::exception& e) {
45832       {
45833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45834       };
45835     } catch (Dali::DaliException e) {
45836       {
45837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45838       };
45839     } catch (...) {
45840       {
45841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45842       };
45843     }
45844   }
45845
45846 }
45847
45848
45849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45850   void * jresult ;
45851   Dali::EncodedBufferImage *arg1 = 0 ;
45852   Dali::EncodedBufferImage *result = 0 ;
45853
45854   arg1 = (Dali::EncodedBufferImage *)jarg1;
45855   if (!arg1) {
45856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45857     return 0;
45858   }
45859   {
45860     try {
45861       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45862     } catch (std::out_of_range& e) {
45863       {
45864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45865       };
45866     } catch (std::exception& e) {
45867       {
45868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45869       };
45870     } catch (Dali::DaliException e) {
45871       {
45872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45873       };
45874     } catch (...) {
45875       {
45876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45877       };
45878     }
45879   }
45880
45881   jresult = (void *)result;
45882   return jresult;
45883 }
45884
45885
45886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45887   void * jresult ;
45888   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45889   Dali::EncodedBufferImage *arg2 = 0 ;
45890   Dali::EncodedBufferImage *result = 0 ;
45891
45892   arg1 = (Dali::EncodedBufferImage *)jarg1;
45893   arg2 = (Dali::EncodedBufferImage *)jarg2;
45894   if (!arg2) {
45895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45896     return 0;
45897   }
45898   {
45899     try {
45900       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45901     } catch (std::out_of_range& e) {
45902       {
45903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45904       };
45905     } catch (std::exception& e) {
45906       {
45907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45908       };
45909     } catch (Dali::DaliException e) {
45910       {
45911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45912       };
45913     } catch (...) {
45914       {
45915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45916       };
45917     }
45918   }
45919
45920   jresult = (void *)result;
45921   return jresult;
45922 }
45923
45924
45925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45926   void * jresult ;
45927   Dali::NativeImage *result = 0 ;
45928
45929   {
45930     try {
45931       result = (Dali::NativeImage *)new Dali::NativeImage();
45932     } catch (std::out_of_range& e) {
45933       {
45934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45935       };
45936     } catch (std::exception& e) {
45937       {
45938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45939       };
45940     } catch (Dali::DaliException e) {
45941       {
45942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45943       };
45944     } catch (...) {
45945       {
45946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45947       };
45948     }
45949   }
45950
45951   jresult = (void *)result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45957   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45958
45959   arg1 = (Dali::NativeImage *)jarg1;
45960   {
45961     try {
45962       delete arg1;
45963     } catch (std::out_of_range& e) {
45964       {
45965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45966       };
45967     } catch (std::exception& e) {
45968       {
45969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45970       };
45971     } catch (Dali::DaliException e) {
45972       {
45973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45974       };
45975     } catch (...) {
45976       {
45977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45978       };
45979     }
45980   }
45981
45982 }
45983
45984
45985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45986   void * jresult ;
45987   Dali::NativeImage *arg1 = 0 ;
45988   Dali::NativeImage *result = 0 ;
45989
45990   arg1 = (Dali::NativeImage *)jarg1;
45991   if (!arg1) {
45992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45993     return 0;
45994   }
45995   {
45996     try {
45997       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45998     } catch (std::out_of_range& e) {
45999       {
46000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46001       };
46002     } catch (std::exception& e) {
46003       {
46004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46005       };
46006     } catch (Dali::DaliException e) {
46007       {
46008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46009       };
46010     } catch (...) {
46011       {
46012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46013       };
46014     }
46015   }
46016
46017   jresult = (void *)result;
46018   return jresult;
46019 }
46020
46021
46022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46023   void * jresult ;
46024   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46025   Dali::NativeImage *arg2 = 0 ;
46026   Dali::NativeImage *result = 0 ;
46027
46028   arg1 = (Dali::NativeImage *)jarg1;
46029   arg2 = (Dali::NativeImage *)jarg2;
46030   if (!arg2) {
46031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46032     return 0;
46033   }
46034   {
46035     try {
46036       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46037     } catch (std::out_of_range& e) {
46038       {
46039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (std::exception& e) {
46042       {
46043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (Dali::DaliException e) {
46046       {
46047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46048       };
46049     } catch (...) {
46050       {
46051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46052       };
46053     }
46054   }
46055
46056   jresult = (void *)result;
46057   return jresult;
46058 }
46059
46060
46061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46062   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46063
46064   arg1 = (Dali::NativeImage *)jarg1;
46065   {
46066     try {
46067       (arg1)->CreateGlTexture();
46068     } catch (std::out_of_range& e) {
46069       {
46070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46071       };
46072     } catch (std::exception& e) {
46073       {
46074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46075       };
46076     } catch (Dali::DaliException e) {
46077       {
46078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46079       };
46080     } catch (...) {
46081       {
46082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46083       };
46084     }
46085   }
46086
46087 }
46088
46089
46090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46091   void * jresult ;
46092   NativeImageInterface *arg1 = 0 ;
46093   Dali::NativeImage result;
46094
46095   arg1 = (NativeImageInterface *)jarg1;
46096   if (!arg1) {
46097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46098     return 0;
46099   }
46100   {
46101     try {
46102       result = Dali::NativeImage::New(*arg1);
46103     } catch (std::out_of_range& e) {
46104       {
46105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46106       };
46107     } catch (std::exception& e) {
46108       {
46109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46110       };
46111     } catch (Dali::DaliException e) {
46112       {
46113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46114       };
46115     } catch (...) {
46116       {
46117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46118       };
46119     }
46120   }
46121
46122   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46123   return jresult;
46124 }
46125
46126
46127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46128   void * jresult ;
46129   Dali::BaseHandle arg1 ;
46130   Dali::BaseHandle *argp1 ;
46131   Dali::NativeImage result;
46132
46133   argp1 = (Dali::BaseHandle *)jarg1;
46134   if (!argp1) {
46135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46136     return 0;
46137   }
46138   arg1 = *argp1;
46139   {
46140     try {
46141       result = Dali::NativeImage::DownCast(arg1);
46142     } catch (std::out_of_range& e) {
46143       {
46144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46145       };
46146     } catch (std::exception& e) {
46147       {
46148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46149       };
46150     } catch (Dali::DaliException e) {
46151       {
46152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46153       };
46154     } catch (...) {
46155       {
46156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46157       };
46158     }
46159   }
46160
46161   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46162   return jresult;
46163 }
46164
46165
46166 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46167   char * jresult ;
46168   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46169   char *result = 0 ;
46170
46171   arg1 = (Dali::NativeImage *)jarg1;
46172   {
46173     try {
46174       result = (char *)(arg1)->GetCustomFragmentPreFix();
46175     } catch (std::out_of_range& e) {
46176       {
46177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46178       };
46179     } catch (std::exception& e) {
46180       {
46181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46182       };
46183     } catch (Dali::DaliException e) {
46184       {
46185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46186       };
46187     } catch (...) {
46188       {
46189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46190       };
46191     }
46192   }
46193
46194   jresult = SWIG_csharp_string_callback((const char *)result);
46195   return jresult;
46196 }
46197
46198
46199 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46200   char * jresult ;
46201   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46202   char *result = 0 ;
46203
46204   arg1 = (Dali::NativeImage *)jarg1;
46205   {
46206     try {
46207       result = (char *)(arg1)->GetCustomSamplerTypename();
46208     } catch (std::out_of_range& e) {
46209       {
46210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46211       };
46212     } catch (std::exception& e) {
46213       {
46214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46215       };
46216     } catch (Dali::DaliException e) {
46217       {
46218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46219       };
46220     } catch (...) {
46221       {
46222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46223       };
46224     }
46225   }
46226
46227   jresult = SWIG_csharp_string_callback((const char *)result);
46228   return jresult;
46229 }
46230
46231
46232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46233   unsigned int jresult ;
46234   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46235   bool result;
46236
46237   arg1 = (Dali::NativeImageInterface *)jarg1;
46238   {
46239     try {
46240       result = (bool)(arg1)->GlExtensionCreate();
46241     } catch (std::out_of_range& e) {
46242       {
46243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46244       };
46245     } catch (std::exception& e) {
46246       {
46247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46248       };
46249     } catch (Dali::DaliException e) {
46250       {
46251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46252       };
46253     } catch (...) {
46254       {
46255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46256       };
46257     }
46258   }
46259
46260   jresult = result;
46261   return jresult;
46262 }
46263
46264
46265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46266   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46267
46268   arg1 = (Dali::NativeImageInterface *)jarg1;
46269   {
46270     try {
46271       (arg1)->GlExtensionDestroy();
46272     } catch (std::out_of_range& e) {
46273       {
46274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46275       };
46276     } catch (std::exception& e) {
46277       {
46278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46279       };
46280     } catch (Dali::DaliException e) {
46281       {
46282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46283       };
46284     } catch (...) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46287       };
46288     }
46289   }
46290
46291 }
46292
46293
46294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46295   unsigned int jresult ;
46296   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46297   unsigned int result;
46298
46299   arg1 = (Dali::NativeImageInterface *)jarg1;
46300   {
46301     try {
46302       result = (unsigned int)(arg1)->TargetTexture();
46303     } catch (std::out_of_range& e) {
46304       {
46305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46306       };
46307     } catch (std::exception& e) {
46308       {
46309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46310       };
46311     } catch (Dali::DaliException e) {
46312       {
46313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46314       };
46315     } catch (...) {
46316       {
46317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46318       };
46319     }
46320   }
46321
46322   jresult = result;
46323   return jresult;
46324 }
46325
46326
46327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46328   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46329
46330   arg1 = (Dali::NativeImageInterface *)jarg1;
46331   {
46332     try {
46333       (arg1)->PrepareTexture();
46334     } catch (std::out_of_range& e) {
46335       {
46336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46337       };
46338     } catch (std::exception& e) {
46339       {
46340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46341       };
46342     } catch (Dali::DaliException e) {
46343       {
46344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46345       };
46346     } catch (...) {
46347       {
46348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46349       };
46350     }
46351   }
46352
46353 }
46354
46355
46356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46357   unsigned int jresult ;
46358   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46359   unsigned int result;
46360
46361   arg1 = (Dali::NativeImageInterface *)jarg1;
46362   {
46363     try {
46364       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46365     } catch (std::out_of_range& e) {
46366       {
46367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46368       };
46369     } catch (std::exception& e) {
46370       {
46371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46372       };
46373     } catch (Dali::DaliException e) {
46374       {
46375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46376       };
46377     } catch (...) {
46378       {
46379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46380       };
46381     }
46382   }
46383
46384   jresult = result;
46385   return jresult;
46386 }
46387
46388
46389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46390   unsigned int jresult ;
46391   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46392   unsigned int result;
46393
46394   arg1 = (Dali::NativeImageInterface *)jarg1;
46395   {
46396     try {
46397       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46398     } catch (std::out_of_range& e) {
46399       {
46400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46401       };
46402     } catch (std::exception& e) {
46403       {
46404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46405       };
46406     } catch (Dali::DaliException e) {
46407       {
46408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46409       };
46410     } catch (...) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46413       };
46414     }
46415   }
46416
46417   jresult = result;
46418   return jresult;
46419 }
46420
46421
46422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46423   unsigned int jresult ;
46424   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46425   bool result;
46426
46427   arg1 = (Dali::NativeImageInterface *)jarg1;
46428   {
46429     try {
46430       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46431     } catch (std::out_of_range& e) {
46432       {
46433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46434       };
46435     } catch (std::exception& e) {
46436       {
46437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46438       };
46439     } catch (Dali::DaliException e) {
46440       {
46441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46442       };
46443     } catch (...) {
46444       {
46445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46446       };
46447     }
46448   }
46449
46450   jresult = result;
46451   return jresult;
46452 }
46453
46454
46455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46456   void * jresult ;
46457   std::string *arg1 = 0 ;
46458   Dali::ImageDimensions result;
46459
46460   if (!jarg1) {
46461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46462     return 0;
46463   }
46464   std::string arg1_str(jarg1);
46465   arg1 = &arg1_str;
46466   {
46467     try {
46468       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46469     } catch (std::out_of_range& e) {
46470       {
46471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46472       };
46473     } catch (std::exception& e) {
46474       {
46475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46476       };
46477     } catch (Dali::DaliException e) {
46478       {
46479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46480       };
46481     } catch (...) {
46482       {
46483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46484       };
46485     }
46486   }
46487
46488   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46489
46490   //argout typemap for const std::string&
46491
46492   return jresult;
46493 }
46494
46495
46496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46497   void * jresult ;
46498   Dali::ResourceImage *result = 0 ;
46499
46500   {
46501     try {
46502       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46503     } catch (std::out_of_range& e) {
46504       {
46505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46506       };
46507     } catch (std::exception& e) {
46508       {
46509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46510       };
46511     } catch (Dali::DaliException e) {
46512       {
46513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46514       };
46515     } catch (...) {
46516       {
46517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46518       };
46519     }
46520   }
46521
46522   jresult = (void *)result;
46523   return jresult;
46524 }
46525
46526
46527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46528   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46529
46530   arg1 = (Dali::ResourceImage *)jarg1;
46531   {
46532     try {
46533       delete arg1;
46534     } catch (std::out_of_range& e) {
46535       {
46536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46537       };
46538     } catch (std::exception& e) {
46539       {
46540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46541       };
46542     } catch (Dali::DaliException e) {
46543       {
46544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46545       };
46546     } catch (...) {
46547       {
46548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46549       };
46550     }
46551   }
46552
46553 }
46554
46555
46556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46557   void * jresult ;
46558   Dali::ResourceImage *arg1 = 0 ;
46559   Dali::ResourceImage *result = 0 ;
46560
46561   arg1 = (Dali::ResourceImage *)jarg1;
46562   if (!arg1) {
46563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46564     return 0;
46565   }
46566   {
46567     try {
46568       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46569     } catch (std::out_of_range& e) {
46570       {
46571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46572       };
46573     } catch (std::exception& e) {
46574       {
46575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46576       };
46577     } catch (Dali::DaliException e) {
46578       {
46579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46580       };
46581     } catch (...) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46584       };
46585     }
46586   }
46587
46588   jresult = (void *)result;
46589   return jresult;
46590 }
46591
46592
46593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46594   void * jresult ;
46595   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46596   Dali::ResourceImage *arg2 = 0 ;
46597   Dali::ResourceImage *result = 0 ;
46598
46599   arg1 = (Dali::ResourceImage *)jarg1;
46600   arg2 = (Dali::ResourceImage *)jarg2;
46601   if (!arg2) {
46602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46603     return 0;
46604   }
46605   {
46606     try {
46607       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46608     } catch (std::out_of_range& e) {
46609       {
46610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46611       };
46612     } catch (std::exception& e) {
46613       {
46614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46615       };
46616     } catch (Dali::DaliException e) {
46617       {
46618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46619       };
46620     } catch (...) {
46621       {
46622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46623       };
46624     }
46625   }
46626
46627   jresult = (void *)result;
46628   return jresult;
46629 }
46630
46631
46632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46633   void * jresult ;
46634   std::string *arg1 = 0 ;
46635   bool arg2 ;
46636   Dali::ResourceImage result;
46637
46638   if (!jarg1) {
46639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46640     return 0;
46641   }
46642   std::string arg1_str(jarg1);
46643   arg1 = &arg1_str;
46644   arg2 = jarg2 ? true : false;
46645   {
46646     try {
46647       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46648     } catch (std::out_of_range& e) {
46649       {
46650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46651       };
46652     } catch (std::exception& e) {
46653       {
46654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46655       };
46656     } catch (Dali::DaliException e) {
46657       {
46658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46659       };
46660     } catch (...) {
46661       {
46662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46663       };
46664     }
46665   }
46666
46667   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46668
46669   //argout typemap for const std::string&
46670
46671   return jresult;
46672 }
46673
46674
46675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46676   void * jresult ;
46677   std::string *arg1 = 0 ;
46678   Dali::ResourceImage result;
46679
46680   if (!jarg1) {
46681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46682     return 0;
46683   }
46684   std::string arg1_str(jarg1);
46685   arg1 = &arg1_str;
46686   {
46687     try {
46688       result = Dali::ResourceImage::New((std::string const &)*arg1);
46689     } catch (std::out_of_range& e) {
46690       {
46691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46692       };
46693     } catch (std::exception& e) {
46694       {
46695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46696       };
46697     } catch (Dali::DaliException e) {
46698       {
46699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46700       };
46701     } catch (...) {
46702       {
46703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46704       };
46705     }
46706   }
46707
46708   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46709
46710   //argout typemap for const std::string&
46711
46712   return jresult;
46713 }
46714
46715
46716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46717   void * jresult ;
46718   std::string *arg1 = 0 ;
46719   Dali::ImageDimensions arg2 ;
46720   Dali::FittingMode::Type arg3 ;
46721   Dali::SamplingMode::Type arg4 ;
46722   bool arg5 ;
46723   Dali::ImageDimensions *argp2 ;
46724   Dali::ResourceImage result;
46725
46726   if (!jarg1) {
46727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46728     return 0;
46729   }
46730   std::string arg1_str(jarg1);
46731   arg1 = &arg1_str;
46732   argp2 = (Dali::ImageDimensions *)jarg2;
46733   if (!argp2) {
46734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46735     return 0;
46736   }
46737   arg2 = *argp2;
46738   arg3 = (Dali::FittingMode::Type)jarg3;
46739   arg4 = (Dali::SamplingMode::Type)jarg4;
46740   arg5 = jarg5 ? true : false;
46741   {
46742     try {
46743       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46744     } catch (std::out_of_range& e) {
46745       {
46746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46747       };
46748     } catch (std::exception& e) {
46749       {
46750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46751       };
46752     } catch (Dali::DaliException e) {
46753       {
46754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46755       };
46756     } catch (...) {
46757       {
46758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46759       };
46760     }
46761   }
46762
46763   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46764
46765   //argout typemap for const std::string&
46766
46767   return jresult;
46768 }
46769
46770
46771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46772   void * jresult ;
46773   std::string *arg1 = 0 ;
46774   Dali::ImageDimensions arg2 ;
46775   Dali::FittingMode::Type arg3 ;
46776   Dali::SamplingMode::Type arg4 ;
46777   Dali::ImageDimensions *argp2 ;
46778   Dali::ResourceImage result;
46779
46780   if (!jarg1) {
46781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46782     return 0;
46783   }
46784   std::string arg1_str(jarg1);
46785   arg1 = &arg1_str;
46786   argp2 = (Dali::ImageDimensions *)jarg2;
46787   if (!argp2) {
46788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46789     return 0;
46790   }
46791   arg2 = *argp2;
46792   arg3 = (Dali::FittingMode::Type)jarg3;
46793   arg4 = (Dali::SamplingMode::Type)jarg4;
46794   {
46795     try {
46796       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46797     } catch (std::out_of_range& e) {
46798       {
46799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46800       };
46801     } catch (std::exception& e) {
46802       {
46803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (Dali::DaliException e) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46808       };
46809     } catch (...) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46812       };
46813     }
46814   }
46815
46816   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46817
46818   //argout typemap for const std::string&
46819
46820   return jresult;
46821 }
46822
46823
46824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46825   void * jresult ;
46826   std::string *arg1 = 0 ;
46827   Dali::ImageDimensions arg2 ;
46828   Dali::FittingMode::Type arg3 ;
46829   Dali::ImageDimensions *argp2 ;
46830   Dali::ResourceImage result;
46831
46832   if (!jarg1) {
46833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46834     return 0;
46835   }
46836   std::string arg1_str(jarg1);
46837   arg1 = &arg1_str;
46838   argp2 = (Dali::ImageDimensions *)jarg2;
46839   if (!argp2) {
46840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46841     return 0;
46842   }
46843   arg2 = *argp2;
46844   arg3 = (Dali::FittingMode::Type)jarg3;
46845   {
46846     try {
46847       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46848     } catch (std::out_of_range& e) {
46849       {
46850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46851       };
46852     } catch (std::exception& e) {
46853       {
46854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46855       };
46856     } catch (Dali::DaliException e) {
46857       {
46858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46859       };
46860     } catch (...) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46863       };
46864     }
46865   }
46866
46867   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46868
46869   //argout typemap for const std::string&
46870
46871   return jresult;
46872 }
46873
46874
46875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46876   void * jresult ;
46877   std::string *arg1 = 0 ;
46878   Dali::ImageDimensions arg2 ;
46879   Dali::ImageDimensions *argp2 ;
46880   Dali::ResourceImage result;
46881
46882   if (!jarg1) {
46883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46884     return 0;
46885   }
46886   std::string arg1_str(jarg1);
46887   arg1 = &arg1_str;
46888   argp2 = (Dali::ImageDimensions *)jarg2;
46889   if (!argp2) {
46890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46891     return 0;
46892   }
46893   arg2 = *argp2;
46894   {
46895     try {
46896       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46897     } catch (std::out_of_range& e) {
46898       {
46899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (std::exception& e) {
46902       {
46903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (Dali::DaliException e) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46908       };
46909     } catch (...) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46912       };
46913     }
46914   }
46915
46916   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46917
46918   //argout typemap for const std::string&
46919
46920   return jresult;
46921 }
46922
46923
46924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46925   void * jresult ;
46926   Dali::BaseHandle arg1 ;
46927   Dali::BaseHandle *argp1 ;
46928   Dali::ResourceImage result;
46929
46930   argp1 = (Dali::BaseHandle *)jarg1;
46931   if (!argp1) {
46932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46933     return 0;
46934   }
46935   arg1 = *argp1;
46936   {
46937     try {
46938       result = Dali::ResourceImage::DownCast(arg1);
46939     } catch (std::out_of_range& e) {
46940       {
46941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46942       };
46943     } catch (std::exception& e) {
46944       {
46945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46946       };
46947     } catch (Dali::DaliException e) {
46948       {
46949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46950       };
46951     } catch (...) {
46952       {
46953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46954       };
46955     }
46956   }
46957
46958   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46959   return jresult;
46960 }
46961
46962
46963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46964   int jresult ;
46965   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46966   Dali::LoadingState result;
46967
46968   arg1 = (Dali::ResourceImage *)jarg1;
46969   {
46970     try {
46971       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46972     } catch (std::out_of_range& e) {
46973       {
46974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46975       };
46976     } catch (std::exception& e) {
46977       {
46978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46979       };
46980     } catch (Dali::DaliException e) {
46981       {
46982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46983       };
46984     } catch (...) {
46985       {
46986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46987       };
46988     }
46989   }
46990
46991   jresult = (int)result;
46992   return jresult;
46993 }
46994
46995
46996 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46997   char * jresult ;
46998   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46999   std::string result;
47000
47001   arg1 = (Dali::ResourceImage *)jarg1;
47002   {
47003     try {
47004       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47005     } catch (std::out_of_range& e) {
47006       {
47007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47008       };
47009     } catch (std::exception& e) {
47010       {
47011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47012       };
47013     } catch (Dali::DaliException e) {
47014       {
47015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47016       };
47017     } catch (...) {
47018       {
47019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47020       };
47021     }
47022   }
47023
47024   jresult = SWIG_csharp_string_callback((&result)->c_str());
47025   return jresult;
47026 }
47027
47028
47029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47030   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47031
47032   arg1 = (Dali::ResourceImage *)jarg1;
47033   {
47034     try {
47035       (arg1)->Reload();
47036     } catch (std::out_of_range& e) {
47037       {
47038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47039       };
47040     } catch (std::exception& e) {
47041       {
47042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47043       };
47044     } catch (Dali::DaliException e) {
47045       {
47046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47047       };
47048     } catch (...) {
47049       {
47050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47051       };
47052     }
47053   }
47054
47055 }
47056
47057
47058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47059   void * jresult ;
47060   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47061   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47062
47063   arg1 = (Dali::ResourceImage *)jarg1;
47064   {
47065     try {
47066       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47067     } catch (std::out_of_range& e) {
47068       {
47069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47070       };
47071     } catch (std::exception& e) {
47072       {
47073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47074       };
47075     } catch (Dali::DaliException e) {
47076       {
47077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47078       };
47079     } catch (...) {
47080       {
47081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47082       };
47083     }
47084   }
47085
47086   jresult = (void *)result;
47087   return jresult;
47088 }
47089
47090
47091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47092   void * jresult ;
47093   Dali::FrameBufferImage *result = 0 ;
47094
47095   {
47096     try {
47097       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47098     } catch (std::out_of_range& e) {
47099       {
47100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47101       };
47102     } catch (std::exception& e) {
47103       {
47104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47105       };
47106     } catch (Dali::DaliException e) {
47107       {
47108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47109       };
47110     } catch (...) {
47111       {
47112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47113       };
47114     }
47115   }
47116
47117   jresult = (void *)result;
47118   return jresult;
47119 }
47120
47121
47122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47123   void * jresult ;
47124   unsigned int arg1 ;
47125   unsigned int arg2 ;
47126   Dali::Pixel::Format arg3 ;
47127   Dali::RenderBuffer::Format arg4 ;
47128   Dali::FrameBufferImage result;
47129
47130   arg1 = (unsigned int)jarg1;
47131   arg2 = (unsigned int)jarg2;
47132   arg3 = (Dali::Pixel::Format)jarg3;
47133   arg4 = (Dali::RenderBuffer::Format)jarg4;
47134   {
47135     try {
47136       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47137     } catch (std::out_of_range& e) {
47138       {
47139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47140       };
47141     } catch (std::exception& e) {
47142       {
47143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (Dali::DaliException e) {
47146       {
47147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47148       };
47149     } catch (...) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47152       };
47153     }
47154   }
47155
47156   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47157   return jresult;
47158 }
47159
47160
47161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47162   void * jresult ;
47163   unsigned int arg1 ;
47164   unsigned int arg2 ;
47165   Dali::Pixel::Format arg3 ;
47166   Dali::FrameBufferImage result;
47167
47168   arg1 = (unsigned int)jarg1;
47169   arg2 = (unsigned int)jarg2;
47170   arg3 = (Dali::Pixel::Format)jarg3;
47171   {
47172     try {
47173       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47174     } catch (std::out_of_range& e) {
47175       {
47176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47177       };
47178     } catch (std::exception& e) {
47179       {
47180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47181       };
47182     } catch (Dali::DaliException e) {
47183       {
47184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47185       };
47186     } catch (...) {
47187       {
47188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47189       };
47190     }
47191   }
47192
47193   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47194   return jresult;
47195 }
47196
47197
47198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47199   void * jresult ;
47200   unsigned int arg1 ;
47201   unsigned int arg2 ;
47202   Dali::FrameBufferImage result;
47203
47204   arg1 = (unsigned int)jarg1;
47205   arg2 = (unsigned int)jarg2;
47206   {
47207     try {
47208       result = Dali::FrameBufferImage::New(arg1,arg2);
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (Dali::DaliException e) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47220       };
47221     } catch (...) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47224       };
47225     }
47226   }
47227
47228   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47229   return jresult;
47230 }
47231
47232
47233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47234   void * jresult ;
47235   unsigned int arg1 ;
47236   Dali::FrameBufferImage result;
47237
47238   arg1 = (unsigned int)jarg1;
47239   {
47240     try {
47241       result = Dali::FrameBufferImage::New(arg1);
47242     } catch (std::out_of_range& e) {
47243       {
47244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (std::exception& e) {
47247       {
47248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47249       };
47250     } catch (Dali::DaliException e) {
47251       {
47252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47253       };
47254     } catch (...) {
47255       {
47256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47257       };
47258     }
47259   }
47260
47261   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47262   return jresult;
47263 }
47264
47265
47266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47267   void * jresult ;
47268   Dali::FrameBufferImage result;
47269
47270   {
47271     try {
47272       result = Dali::FrameBufferImage::New();
47273     } catch (std::out_of_range& e) {
47274       {
47275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47276       };
47277     } catch (std::exception& e) {
47278       {
47279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47280       };
47281     } catch (Dali::DaliException e) {
47282       {
47283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47284       };
47285     } catch (...) {
47286       {
47287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47288       };
47289     }
47290   }
47291
47292   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47293   return jresult;
47294 }
47295
47296
47297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47298   void * jresult ;
47299   Dali::NativeImageInterface *arg1 = 0 ;
47300   Dali::FrameBufferImage result;
47301
47302   arg1 = (Dali::NativeImageInterface *)jarg1;
47303   if (!arg1) {
47304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47305     return 0;
47306   }
47307   {
47308     try {
47309       result = Dali::FrameBufferImage::New(*arg1);
47310     } catch (std::out_of_range& e) {
47311       {
47312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47313       };
47314     } catch (std::exception& e) {
47315       {
47316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47317       };
47318     } catch (Dali::DaliException e) {
47319       {
47320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47321       };
47322     } catch (...) {
47323       {
47324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47325       };
47326     }
47327   }
47328
47329   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47330   return jresult;
47331 }
47332
47333
47334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47335   void * jresult ;
47336   Dali::BaseHandle arg1 ;
47337   Dali::BaseHandle *argp1 ;
47338   Dali::FrameBufferImage result;
47339
47340   argp1 = (Dali::BaseHandle *)jarg1;
47341   if (!argp1) {
47342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47343     return 0;
47344   }
47345   arg1 = *argp1;
47346   {
47347     try {
47348       result = Dali::FrameBufferImage::DownCast(arg1);
47349     } catch (std::out_of_range& e) {
47350       {
47351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47352       };
47353     } catch (std::exception& e) {
47354       {
47355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47356       };
47357     } catch (Dali::DaliException e) {
47358       {
47359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47360       };
47361     } catch (...) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47364       };
47365     }
47366   }
47367
47368   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47369   return jresult;
47370 }
47371
47372
47373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47374   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47375
47376   arg1 = (Dali::FrameBufferImage *)jarg1;
47377   {
47378     try {
47379       delete arg1;
47380     } catch (std::out_of_range& e) {
47381       {
47382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47383       };
47384     } catch (std::exception& e) {
47385       {
47386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47387       };
47388     } catch (Dali::DaliException e) {
47389       {
47390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47391       };
47392     } catch (...) {
47393       {
47394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47395       };
47396     }
47397   }
47398
47399 }
47400
47401
47402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47403   void * jresult ;
47404   Dali::FrameBufferImage *arg1 = 0 ;
47405   Dali::FrameBufferImage *result = 0 ;
47406
47407   arg1 = (Dali::FrameBufferImage *)jarg1;
47408   if (!arg1) {
47409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47410     return 0;
47411   }
47412   {
47413     try {
47414       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47415     } catch (std::out_of_range& e) {
47416       {
47417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47418       };
47419     } catch (std::exception& e) {
47420       {
47421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47422       };
47423     } catch (Dali::DaliException e) {
47424       {
47425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47426       };
47427     } catch (...) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47430       };
47431     }
47432   }
47433
47434   jresult = (void *)result;
47435   return jresult;
47436 }
47437
47438
47439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47440   void * jresult ;
47441   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47442   Dali::FrameBufferImage *arg2 = 0 ;
47443   Dali::FrameBufferImage *result = 0 ;
47444
47445   arg1 = (Dali::FrameBufferImage *)jarg1;
47446   arg2 = (Dali::FrameBufferImage *)jarg2;
47447   if (!arg2) {
47448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47449     return 0;
47450   }
47451   {
47452     try {
47453       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47454     } catch (std::out_of_range& e) {
47455       {
47456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47457       };
47458     } catch (std::exception& e) {
47459       {
47460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47461       };
47462     } catch (Dali::DaliException e) {
47463       {
47464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47465       };
47466     } catch (...) {
47467       {
47468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47469       };
47470     }
47471   }
47472
47473   jresult = (void *)result;
47474   return jresult;
47475 }
47476
47477
47478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47479   void * jresult ;
47480   Dali::NinePatchImage *result = 0 ;
47481
47482   {
47483     try {
47484       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47485     } catch (std::out_of_range& e) {
47486       {
47487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47488       };
47489     } catch (std::exception& e) {
47490       {
47491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47492       };
47493     } catch (Dali::DaliException e) {
47494       {
47495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47496       };
47497     } catch (...) {
47498       {
47499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47500       };
47501     }
47502   }
47503
47504   jresult = (void *)result;
47505   return jresult;
47506 }
47507
47508
47509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47510   void * jresult ;
47511   std::string *arg1 = 0 ;
47512   Dali::NinePatchImage result;
47513
47514   if (!jarg1) {
47515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47516     return 0;
47517   }
47518   std::string arg1_str(jarg1);
47519   arg1 = &arg1_str;
47520   {
47521     try {
47522       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47523     } catch (std::out_of_range& e) {
47524       {
47525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47526       };
47527     } catch (std::exception& e) {
47528       {
47529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47530       };
47531     } catch (Dali::DaliException e) {
47532       {
47533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47534       };
47535     } catch (...) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47538       };
47539     }
47540   }
47541
47542   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47543
47544   //argout typemap for const std::string&
47545
47546   return jresult;
47547 }
47548
47549
47550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47551   void * jresult ;
47552   Dali::BaseHandle arg1 ;
47553   Dali::BaseHandle *argp1 ;
47554   Dali::NinePatchImage result;
47555
47556   argp1 = (Dali::BaseHandle *)jarg1;
47557   if (!argp1) {
47558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47559     return 0;
47560   }
47561   arg1 = *argp1;
47562   {
47563     try {
47564       result = Dali::NinePatchImage::DownCast(arg1);
47565     } catch (std::out_of_range& e) {
47566       {
47567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47568       };
47569     } catch (std::exception& e) {
47570       {
47571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47572       };
47573     } catch (Dali::DaliException e) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47576       };
47577     } catch (...) {
47578       {
47579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47580       };
47581     }
47582   }
47583
47584   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47585   return jresult;
47586 }
47587
47588
47589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47590   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47591
47592   arg1 = (Dali::NinePatchImage *)jarg1;
47593   {
47594     try {
47595       delete arg1;
47596     } catch (std::out_of_range& e) {
47597       {
47598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47599       };
47600     } catch (std::exception& e) {
47601       {
47602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47603       };
47604     } catch (Dali::DaliException e) {
47605       {
47606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47607       };
47608     } catch (...) {
47609       {
47610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47611       };
47612     }
47613   }
47614
47615 }
47616
47617
47618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47619   void * jresult ;
47620   Dali::NinePatchImage *arg1 = 0 ;
47621   Dali::NinePatchImage *result = 0 ;
47622
47623   arg1 = (Dali::NinePatchImage *)jarg1;
47624   if (!arg1) {
47625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47626     return 0;
47627   }
47628   {
47629     try {
47630       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47631     } catch (std::out_of_range& e) {
47632       {
47633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47634       };
47635     } catch (std::exception& e) {
47636       {
47637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47638       };
47639     } catch (Dali::DaliException e) {
47640       {
47641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47642       };
47643     } catch (...) {
47644       {
47645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47646       };
47647     }
47648   }
47649
47650   jresult = (void *)result;
47651   return jresult;
47652 }
47653
47654
47655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47656   void * jresult ;
47657   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47658   Dali::NinePatchImage *arg2 = 0 ;
47659   Dali::NinePatchImage *result = 0 ;
47660
47661   arg1 = (Dali::NinePatchImage *)jarg1;
47662   arg2 = (Dali::NinePatchImage *)jarg2;
47663   if (!arg2) {
47664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47665     return 0;
47666   }
47667   {
47668     try {
47669       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47670     } catch (std::out_of_range& e) {
47671       {
47672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47673       };
47674     } catch (std::exception& e) {
47675       {
47676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47677       };
47678     } catch (Dali::DaliException e) {
47679       {
47680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47681       };
47682     } catch (...) {
47683       {
47684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47685       };
47686     }
47687   }
47688
47689   jresult = (void *)result;
47690   return jresult;
47691 }
47692
47693
47694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47695   void * jresult ;
47696   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47697   Dali::Vector4 result;
47698
47699   arg1 = (Dali::NinePatchImage *)jarg1;
47700   {
47701     try {
47702       result = (arg1)->GetStretchBorders();
47703     } catch (std::out_of_range& e) {
47704       {
47705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47706       };
47707     } catch (std::exception& e) {
47708       {
47709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (Dali::DaliException e) {
47712       {
47713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47714       };
47715     } catch (...) {
47716       {
47717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47718       };
47719     }
47720   }
47721
47722   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47723   return jresult;
47724 }
47725
47726
47727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47728   void * jresult ;
47729   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47730   Dali::NinePatchImage::StretchRanges *result = 0 ;
47731
47732   arg1 = (Dali::NinePatchImage *)jarg1;
47733   {
47734     try {
47735       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47736     } catch (std::out_of_range& e) {
47737       {
47738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47739       };
47740     } catch (std::exception& e) {
47741       {
47742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47743       };
47744     } catch (Dali::DaliException e) {
47745       {
47746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47747       };
47748     } catch (...) {
47749       {
47750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47751       };
47752     }
47753   }
47754
47755   jresult = (void *)result;
47756   return jresult;
47757 }
47758
47759
47760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47761   void * jresult ;
47762   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47763   Dali::NinePatchImage::StretchRanges *result = 0 ;
47764
47765   arg1 = (Dali::NinePatchImage *)jarg1;
47766   {
47767     try {
47768       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47769     } catch (std::out_of_range& e) {
47770       {
47771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47772       };
47773     } catch (std::exception& e) {
47774       {
47775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (Dali::DaliException e) {
47778       {
47779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47780       };
47781     } catch (...) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47784       };
47785     }
47786   }
47787
47788   jresult = (void *)result;
47789   return jresult;
47790 }
47791
47792
47793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47794   void * jresult ;
47795   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47796   Dali::Rect< int > result;
47797
47798   arg1 = (Dali::NinePatchImage *)jarg1;
47799   {
47800     try {
47801       result = (arg1)->GetChildRectangle();
47802     } catch (std::out_of_range& e) {
47803       {
47804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47805       };
47806     } catch (std::exception& e) {
47807       {
47808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47809       };
47810     } catch (Dali::DaliException e) {
47811       {
47812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47813       };
47814     } catch (...) {
47815       {
47816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47817       };
47818     }
47819   }
47820
47821   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47822   return jresult;
47823 }
47824
47825
47826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47827   void * jresult ;
47828   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47829   Dali::BufferImage result;
47830
47831   arg1 = (Dali::NinePatchImage *)jarg1;
47832   {
47833     try {
47834       result = (arg1)->CreateCroppedBufferImage();
47835     } catch (std::out_of_range& e) {
47836       {
47837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47838       };
47839     } catch (std::exception& e) {
47840       {
47841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47842       };
47843     } catch (Dali::DaliException e) {
47844       {
47845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47846       };
47847     } catch (...) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47850       };
47851     }
47852   }
47853
47854   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47855   return jresult;
47856 }
47857
47858
47859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47860   unsigned int jresult ;
47861   std::string *arg1 = 0 ;
47862   bool result;
47863
47864   if (!jarg1) {
47865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47866     return 0;
47867   }
47868   std::string arg1_str(jarg1);
47869   arg1 = &arg1_str;
47870   {
47871     try {
47872       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47873     } catch (std::out_of_range& e) {
47874       {
47875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (std::exception& e) {
47878       {
47879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (Dali::DaliException e) {
47882       {
47883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47884       };
47885     } catch (...) {
47886       {
47887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47888       };
47889     }
47890   }
47891
47892   jresult = result;
47893
47894   //argout typemap for const std::string&
47895
47896   return jresult;
47897 }
47898
47899
47900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47901   int jresult ;
47902   int result;
47903
47904   result = (int)Dali::CameraActor::Property::TYPE;
47905   jresult = (int)result;
47906   return jresult;
47907 }
47908
47909
47910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47911   int jresult ;
47912   int result;
47913
47914   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47915   jresult = (int)result;
47916   return jresult;
47917 }
47918
47919
47920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47921   int jresult ;
47922   int result;
47923
47924   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47925   jresult = (int)result;
47926   return jresult;
47927 }
47928
47929
47930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47931   int jresult ;
47932   int result;
47933
47934   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47935   jresult = (int)result;
47936   return jresult;
47937 }
47938
47939
47940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47941   int jresult ;
47942   int result;
47943
47944   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47945   jresult = (int)result;
47946   return jresult;
47947 }
47948
47949
47950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47951   int jresult ;
47952   int result;
47953
47954   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47955   jresult = (int)result;
47956   return jresult;
47957 }
47958
47959
47960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47961   int jresult ;
47962   int result;
47963
47964   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47965   jresult = (int)result;
47966   return jresult;
47967 }
47968
47969
47970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47971   int jresult ;
47972   int result;
47973
47974   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47975   jresult = (int)result;
47976   return jresult;
47977 }
47978
47979
47980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47981   int jresult ;
47982   int result;
47983
47984   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47985   jresult = (int)result;
47986   return jresult;
47987 }
47988
47989
47990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47991   int jresult ;
47992   int result;
47993
47994   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47995   jresult = (int)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48001   int jresult ;
48002   int result;
48003
48004   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48005   jresult = (int)result;
48006   return jresult;
48007 }
48008
48009
48010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48011   int jresult ;
48012   int result;
48013
48014   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48015   jresult = (int)result;
48016   return jresult;
48017 }
48018
48019
48020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48021   int jresult ;
48022   int result;
48023
48024   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48025   jresult = (int)result;
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48031   int jresult ;
48032   int result;
48033
48034   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48035   jresult = (int)result;
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48041   void * jresult ;
48042   Dali::CameraActor::Property *result = 0 ;
48043
48044   {
48045     try {
48046       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48047     } catch (std::out_of_range& e) {
48048       {
48049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48050       };
48051     } catch (std::exception& e) {
48052       {
48053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48054       };
48055     } catch (Dali::DaliException e) {
48056       {
48057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48058       };
48059     } catch (...) {
48060       {
48061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48062       };
48063     }
48064   }
48065
48066   jresult = (void *)result;
48067   return jresult;
48068 }
48069
48070
48071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48072   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48073
48074   arg1 = (Dali::CameraActor::Property *)jarg1;
48075   {
48076     try {
48077       delete arg1;
48078     } catch (std::out_of_range& e) {
48079       {
48080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48081       };
48082     } catch (std::exception& e) {
48083       {
48084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48085       };
48086     } catch (Dali::DaliException e) {
48087       {
48088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48089       };
48090     } catch (...) {
48091       {
48092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48093       };
48094     }
48095   }
48096
48097 }
48098
48099
48100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48101   void * jresult ;
48102   Dali::CameraActor *result = 0 ;
48103
48104   {
48105     try {
48106       result = (Dali::CameraActor *)new Dali::CameraActor();
48107     } catch (std::out_of_range& e) {
48108       {
48109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48110       };
48111     } catch (std::exception& e) {
48112       {
48113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48114       };
48115     } catch (Dali::DaliException e) {
48116       {
48117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48118       };
48119     } catch (...) {
48120       {
48121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48122       };
48123     }
48124   }
48125
48126   jresult = (void *)result;
48127   return jresult;
48128 }
48129
48130
48131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48132   void * jresult ;
48133   Dali::CameraActor result;
48134
48135   {
48136     try {
48137       result = Dali::CameraActor::New();
48138     } catch (std::out_of_range& e) {
48139       {
48140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48141       };
48142     } catch (std::exception& e) {
48143       {
48144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48145       };
48146     } catch (Dali::DaliException e) {
48147       {
48148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48149       };
48150     } catch (...) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48153       };
48154     }
48155   }
48156
48157   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48158   return jresult;
48159 }
48160
48161
48162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48163   void * jresult ;
48164   Dali::Size *arg1 = 0 ;
48165   Dali::CameraActor result;
48166
48167   arg1 = (Dali::Size *)jarg1;
48168   if (!arg1) {
48169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48170     return 0;
48171   }
48172   {
48173     try {
48174       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48175     } catch (std::out_of_range& e) {
48176       {
48177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48178       };
48179     } catch (std::exception& e) {
48180       {
48181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48182       };
48183     } catch (Dali::DaliException e) {
48184       {
48185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48186       };
48187     } catch (...) {
48188       {
48189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48190       };
48191     }
48192   }
48193
48194   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48195   return jresult;
48196 }
48197
48198
48199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48200   void * jresult ;
48201   Dali::BaseHandle arg1 ;
48202   Dali::BaseHandle *argp1 ;
48203   Dali::CameraActor result;
48204
48205   argp1 = (Dali::BaseHandle *)jarg1;
48206   if (!argp1) {
48207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48208     return 0;
48209   }
48210   arg1 = *argp1;
48211   {
48212     try {
48213       result = Dali::CameraActor::DownCast(arg1);
48214     } catch (std::out_of_range& e) {
48215       {
48216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48217       };
48218     } catch (std::exception& e) {
48219       {
48220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48221       };
48222     } catch (Dali::DaliException e) {
48223       {
48224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48225       };
48226     } catch (...) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48229       };
48230     }
48231   }
48232
48233   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48234   return jresult;
48235 }
48236
48237
48238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48239   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48240
48241   arg1 = (Dali::CameraActor *)jarg1;
48242   {
48243     try {
48244       delete arg1;
48245     } catch (std::out_of_range& e) {
48246       {
48247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (std::exception& e) {
48250       {
48251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (Dali::DaliException e) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48256       };
48257     } catch (...) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48260       };
48261     }
48262   }
48263
48264 }
48265
48266
48267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48268   void * jresult ;
48269   Dali::CameraActor *arg1 = 0 ;
48270   Dali::CameraActor *result = 0 ;
48271
48272   arg1 = (Dali::CameraActor *)jarg1;
48273   if (!arg1) {
48274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48275     return 0;
48276   }
48277   {
48278     try {
48279       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48280     } catch (std::out_of_range& e) {
48281       {
48282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48283       };
48284     } catch (std::exception& e) {
48285       {
48286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48287       };
48288     } catch (Dali::DaliException e) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48291       };
48292     } catch (...) {
48293       {
48294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48295       };
48296     }
48297   }
48298
48299   jresult = (void *)result;
48300   return jresult;
48301 }
48302
48303
48304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48305   void * jresult ;
48306   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48307   Dali::CameraActor *arg2 = 0 ;
48308   Dali::CameraActor *result = 0 ;
48309
48310   arg1 = (Dali::CameraActor *)jarg1;
48311   arg2 = (Dali::CameraActor *)jarg2;
48312   if (!arg2) {
48313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48314     return 0;
48315   }
48316   {
48317     try {
48318       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48319     } catch (std::out_of_range& e) {
48320       {
48321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48322       };
48323     } catch (std::exception& e) {
48324       {
48325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48326       };
48327     } catch (Dali::DaliException e) {
48328       {
48329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48330       };
48331     } catch (...) {
48332       {
48333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48334       };
48335     }
48336   }
48337
48338   jresult = (void *)result;
48339   return jresult;
48340 }
48341
48342
48343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48344   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48345   Dali::Camera::Type arg2 ;
48346
48347   arg1 = (Dali::CameraActor *)jarg1;
48348   arg2 = (Dali::Camera::Type)jarg2;
48349   {
48350     try {
48351       (arg1)->SetType(arg2);
48352     } catch (std::out_of_range& e) {
48353       {
48354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48355       };
48356     } catch (std::exception& e) {
48357       {
48358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48359       };
48360     } catch (Dali::DaliException e) {
48361       {
48362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48363       };
48364     } catch (...) {
48365       {
48366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48367       };
48368     }
48369   }
48370
48371 }
48372
48373
48374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48375   int jresult ;
48376   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48377   Dali::Camera::Type result;
48378
48379   arg1 = (Dali::CameraActor *)jarg1;
48380   {
48381     try {
48382       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48383     } catch (std::out_of_range& e) {
48384       {
48385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48386       };
48387     } catch (std::exception& e) {
48388       {
48389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48390       };
48391     } catch (Dali::DaliException e) {
48392       {
48393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48394       };
48395     } catch (...) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48398       };
48399     }
48400   }
48401
48402   jresult = (int)result;
48403   return jresult;
48404 }
48405
48406
48407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48408   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48409   Dali::Camera::ProjectionMode arg2 ;
48410
48411   arg1 = (Dali::CameraActor *)jarg1;
48412   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48413   {
48414     try {
48415       (arg1)->SetProjectionMode(arg2);
48416     } catch (std::out_of_range& e) {
48417       {
48418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48419       };
48420     } catch (std::exception& e) {
48421       {
48422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48423       };
48424     } catch (Dali::DaliException e) {
48425       {
48426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48427       };
48428     } catch (...) {
48429       {
48430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48431       };
48432     }
48433   }
48434
48435 }
48436
48437
48438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48439   int jresult ;
48440   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48441   Dali::Camera::ProjectionMode result;
48442
48443   arg1 = (Dali::CameraActor *)jarg1;
48444   {
48445     try {
48446       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48447     } catch (std::out_of_range& e) {
48448       {
48449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48450       };
48451     } catch (std::exception& e) {
48452       {
48453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48454       };
48455     } catch (Dali::DaliException e) {
48456       {
48457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48458       };
48459     } catch (...) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48462       };
48463     }
48464   }
48465
48466   jresult = (int)result;
48467   return jresult;
48468 }
48469
48470
48471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48472   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48473   float arg2 ;
48474
48475   arg1 = (Dali::CameraActor *)jarg1;
48476   arg2 = (float)jarg2;
48477   {
48478     try {
48479       (arg1)->SetFieldOfView(arg2);
48480     } catch (std::out_of_range& e) {
48481       {
48482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48483       };
48484     } catch (std::exception& e) {
48485       {
48486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48487       };
48488     } catch (Dali::DaliException e) {
48489       {
48490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48491       };
48492     } catch (...) {
48493       {
48494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48495       };
48496     }
48497   }
48498
48499 }
48500
48501
48502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48503   float jresult ;
48504   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48505   float result;
48506
48507   arg1 = (Dali::CameraActor *)jarg1;
48508   {
48509     try {
48510       result = (float)(arg1)->GetFieldOfView();
48511     } catch (std::out_of_range& e) {
48512       {
48513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48514       };
48515     } catch (std::exception& e) {
48516       {
48517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48518       };
48519     } catch (Dali::DaliException e) {
48520       {
48521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48522       };
48523     } catch (...) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48526       };
48527     }
48528   }
48529
48530   jresult = result;
48531   return jresult;
48532 }
48533
48534
48535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48536   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48537   float arg2 ;
48538
48539   arg1 = (Dali::CameraActor *)jarg1;
48540   arg2 = (float)jarg2;
48541   {
48542     try {
48543       (arg1)->SetAspectRatio(arg2);
48544     } catch (std::out_of_range& e) {
48545       {
48546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48547       };
48548     } catch (std::exception& e) {
48549       {
48550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48551       };
48552     } catch (Dali::DaliException e) {
48553       {
48554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48555       };
48556     } catch (...) {
48557       {
48558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48559       };
48560     }
48561   }
48562
48563 }
48564
48565
48566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48567   float jresult ;
48568   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48569   float result;
48570
48571   arg1 = (Dali::CameraActor *)jarg1;
48572   {
48573     try {
48574       result = (float)(arg1)->GetAspectRatio();
48575     } catch (std::out_of_range& e) {
48576       {
48577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48578       };
48579     } catch (std::exception& e) {
48580       {
48581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48582       };
48583     } catch (Dali::DaliException e) {
48584       {
48585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48586       };
48587     } catch (...) {
48588       {
48589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48590       };
48591     }
48592   }
48593
48594   jresult = result;
48595   return jresult;
48596 }
48597
48598
48599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48600   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48601   float arg2 ;
48602
48603   arg1 = (Dali::CameraActor *)jarg1;
48604   arg2 = (float)jarg2;
48605   {
48606     try {
48607       (arg1)->SetNearClippingPlane(arg2);
48608     } catch (std::out_of_range& e) {
48609       {
48610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48611       };
48612     } catch (std::exception& e) {
48613       {
48614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48615       };
48616     } catch (Dali::DaliException e) {
48617       {
48618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48619       };
48620     } catch (...) {
48621       {
48622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48623       };
48624     }
48625   }
48626
48627 }
48628
48629
48630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48631   float jresult ;
48632   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48633   float result;
48634
48635   arg1 = (Dali::CameraActor *)jarg1;
48636   {
48637     try {
48638       result = (float)(arg1)->GetNearClippingPlane();
48639     } catch (std::out_of_range& e) {
48640       {
48641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48642       };
48643     } catch (std::exception& e) {
48644       {
48645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48646       };
48647     } catch (Dali::DaliException e) {
48648       {
48649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48650       };
48651     } catch (...) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48654       };
48655     }
48656   }
48657
48658   jresult = result;
48659   return jresult;
48660 }
48661
48662
48663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48664   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48665   float arg2 ;
48666
48667   arg1 = (Dali::CameraActor *)jarg1;
48668   arg2 = (float)jarg2;
48669   {
48670     try {
48671       (arg1)->SetFarClippingPlane(arg2);
48672     } catch (std::out_of_range& e) {
48673       {
48674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48675       };
48676     } catch (std::exception& e) {
48677       {
48678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48679       };
48680     } catch (Dali::DaliException e) {
48681       {
48682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48683       };
48684     } catch (...) {
48685       {
48686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48687       };
48688     }
48689   }
48690
48691 }
48692
48693
48694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48695   float jresult ;
48696   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48697   float result;
48698
48699   arg1 = (Dali::CameraActor *)jarg1;
48700   {
48701     try {
48702       result = (float)(arg1)->GetFarClippingPlane();
48703     } catch (std::out_of_range& e) {
48704       {
48705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48706       };
48707     } catch (std::exception& e) {
48708       {
48709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48710       };
48711     } catch (Dali::DaliException e) {
48712       {
48713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48714       };
48715     } catch (...) {
48716       {
48717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48718       };
48719     }
48720   }
48721
48722   jresult = result;
48723   return jresult;
48724 }
48725
48726
48727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48728   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48729   Dali::Vector3 *arg2 = 0 ;
48730
48731   arg1 = (Dali::CameraActor *)jarg1;
48732   arg2 = (Dali::Vector3 *)jarg2;
48733   if (!arg2) {
48734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48735     return ;
48736   }
48737   {
48738     try {
48739       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48740     } catch (std::out_of_range& e) {
48741       {
48742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48743       };
48744     } catch (std::exception& e) {
48745       {
48746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48747       };
48748     } catch (Dali::DaliException e) {
48749       {
48750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48751       };
48752     } catch (...) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48755       };
48756     }
48757   }
48758
48759 }
48760
48761
48762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48763   void * jresult ;
48764   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48765   Dali::Vector3 result;
48766
48767   arg1 = (Dali::CameraActor *)jarg1;
48768   {
48769     try {
48770       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48771     } catch (std::out_of_range& e) {
48772       {
48773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48774       };
48775     } catch (std::exception& e) {
48776       {
48777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48778       };
48779     } catch (Dali::DaliException e) {
48780       {
48781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48782       };
48783     } catch (...) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48786       };
48787     }
48788   }
48789
48790   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48791   return jresult;
48792 }
48793
48794
48795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48796   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48797   bool arg2 ;
48798
48799   arg1 = (Dali::CameraActor *)jarg1;
48800   arg2 = jarg2 ? true : false;
48801   {
48802     try {
48803       (arg1)->SetInvertYAxis(arg2);
48804     } catch (std::out_of_range& e) {
48805       {
48806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48807       };
48808     } catch (std::exception& e) {
48809       {
48810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48811       };
48812     } catch (Dali::DaliException e) {
48813       {
48814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48815       };
48816     } catch (...) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48819       };
48820     }
48821   }
48822
48823 }
48824
48825
48826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48827   unsigned int jresult ;
48828   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48829   bool result;
48830
48831   arg1 = (Dali::CameraActor *)jarg1;
48832   {
48833     try {
48834       result = (bool)(arg1)->GetInvertYAxis();
48835     } catch (std::out_of_range& e) {
48836       {
48837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48838       };
48839     } catch (std::exception& e) {
48840       {
48841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48842       };
48843     } catch (Dali::DaliException e) {
48844       {
48845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48846       };
48847     } catch (...) {
48848       {
48849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48850       };
48851     }
48852   }
48853
48854   jresult = result;
48855   return jresult;
48856 }
48857
48858
48859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48860   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48861   Dali::Size *arg2 = 0 ;
48862
48863   arg1 = (Dali::CameraActor *)jarg1;
48864   arg2 = (Dali::Size *)jarg2;
48865   if (!arg2) {
48866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48867     return ;
48868   }
48869   {
48870     try {
48871       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48872     } catch (std::out_of_range& e) {
48873       {
48874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48875       };
48876     } catch (std::exception& e) {
48877       {
48878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48879       };
48880     } catch (Dali::DaliException e) {
48881       {
48882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48883       };
48884     } catch (...) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48887       };
48888     }
48889   }
48890
48891 }
48892
48893
48894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48895   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48896   Dali::Size *arg2 = 0 ;
48897
48898   arg1 = (Dali::CameraActor *)jarg1;
48899   arg2 = (Dali::Size *)jarg2;
48900   if (!arg2) {
48901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48902     return ;
48903   }
48904   {
48905     try {
48906       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48907     } catch (std::out_of_range& e) {
48908       {
48909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48910       };
48911     } catch (std::exception& e) {
48912       {
48913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48914       };
48915     } catch (Dali::DaliException e) {
48916       {
48917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48918       };
48919     } catch (...) {
48920       {
48921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48922       };
48923     }
48924   }
48925
48926 }
48927
48928
48929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48930   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48931   float arg2 ;
48932   float arg3 ;
48933   float arg4 ;
48934   float arg5 ;
48935   float arg6 ;
48936   float arg7 ;
48937
48938   arg1 = (Dali::CameraActor *)jarg1;
48939   arg2 = (float)jarg2;
48940   arg3 = (float)jarg3;
48941   arg4 = (float)jarg4;
48942   arg5 = (float)jarg5;
48943   arg6 = (float)jarg6;
48944   arg7 = (float)jarg7;
48945   {
48946     try {
48947       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48948     } catch (std::out_of_range& e) {
48949       {
48950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48951       };
48952     } catch (std::exception& e) {
48953       {
48954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48955       };
48956     } catch (Dali::DaliException e) {
48957       {
48958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48959       };
48960     } catch (...) {
48961       {
48962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48963       };
48964     }
48965   }
48966
48967 }
48968
48969
48970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48971   void * jresult ;
48972   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48973
48974   {
48975     try {
48976       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48977     } catch (std::out_of_range& e) {
48978       {
48979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48980       };
48981     } catch (std::exception& e) {
48982       {
48983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48984       };
48985     } catch (Dali::DaliException e) {
48986       {
48987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48988       };
48989     } catch (...) {
48990       {
48991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48992       };
48993     }
48994   }
48995
48996   jresult = (void *)result;
48997   return jresult;
48998 }
48999
49000
49001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49002   void * jresult ;
49003   std::string arg1 ;
49004   Dali::Property::Value arg2 ;
49005   Dali::Property::Value *argp2 ;
49006   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49007
49008   if (!jarg1) {
49009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49010     return 0;
49011   }
49012   (&arg1)->assign(jarg1);
49013   argp2 = (Dali::Property::Value *)jarg2;
49014   if (!argp2) {
49015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49016     return 0;
49017   }
49018   arg2 = *argp2;
49019   {
49020     try {
49021       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49022     } catch (std::out_of_range& e) {
49023       {
49024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49025       };
49026     } catch (std::exception& e) {
49027       {
49028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49029       };
49030     } catch (Dali::DaliException e) {
49031       {
49032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49033       };
49034     } catch (...) {
49035       {
49036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49037       };
49038     }
49039   }
49040
49041   jresult = (void *)result;
49042   return jresult;
49043 }
49044
49045
49046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49047   void * jresult ;
49048   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49049   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49050
49051   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49052   if (!arg1) {
49053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49054     return 0;
49055   }
49056   {
49057     try {
49058       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);
49059     } catch (std::out_of_range& e) {
49060       {
49061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49062       };
49063     } catch (std::exception& e) {
49064       {
49065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49066       };
49067     } catch (Dali::DaliException e) {
49068       {
49069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49070       };
49071     } catch (...) {
49072       {
49073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49074       };
49075     }
49076   }
49077
49078   jresult = (void *)result;
49079   return jresult;
49080 }
49081
49082
49083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49084   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49085   std::string *arg2 = 0 ;
49086
49087   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49088   if (!jarg2) {
49089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49090     return ;
49091   }
49092   std::string arg2_str(jarg2);
49093   arg2 = &arg2_str;
49094   if (arg1) (arg1)->first = *arg2;
49095
49096   //argout typemap for const std::string&
49097
49098 }
49099
49100
49101 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49102   char * jresult ;
49103   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49104   std::string *result = 0 ;
49105
49106   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49107   result = (std::string *) & ((arg1)->first);
49108   jresult = SWIG_csharp_string_callback(result->c_str());
49109   return jresult;
49110 }
49111
49112
49113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49114   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49115   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49116
49117   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49118   arg2 = (Dali::Property::Value *)jarg2;
49119   if (arg1) (arg1)->second = *arg2;
49120 }
49121
49122
49123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49124   void * jresult ;
49125   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49126   Dali::Property::Value *result = 0 ;
49127
49128   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49129   result = (Dali::Property::Value *)& ((arg1)->second);
49130   jresult = (void *)result;
49131   return jresult;
49132 }
49133
49134
49135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49136   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49137
49138   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49139   {
49140     try {
49141       delete arg1;
49142     } catch (std::out_of_range& e) {
49143       {
49144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49145       };
49146     } catch (std::exception& e) {
49147       {
49148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49149       };
49150     } catch (Dali::DaliException e) {
49151       {
49152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49153       };
49154     } catch (...) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49157       };
49158     }
49159   }
49160
49161 }
49162
49163
49164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49165   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49166
49167   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49168   {
49169     try {
49170       (arg1)->clear();
49171     } catch (std::out_of_range& e) {
49172       {
49173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49174       };
49175     } catch (std::exception& e) {
49176       {
49177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49178       };
49179     } catch (Dali::DaliException e) {
49180       {
49181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49182       };
49183     } catch (...) {
49184       {
49185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49186       };
49187     }
49188   }
49189
49190 }
49191
49192
49193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49194   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49195   Dali::TouchPoint *arg2 = 0 ;
49196
49197   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49198   arg2 = (Dali::TouchPoint *)jarg2;
49199   if (!arg2) {
49200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49201     return ;
49202   }
49203   {
49204     try {
49205       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49206     } catch (std::out_of_range& e) {
49207       {
49208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49209       };
49210     } catch (std::exception& e) {
49211       {
49212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (Dali::DaliException e) {
49215       {
49216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49217       };
49218     } catch (...) {
49219       {
49220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49221       };
49222     }
49223   }
49224
49225 }
49226
49227
49228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49229   unsigned long jresult ;
49230   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49231   std::vector< Dali::TouchPoint >::size_type result;
49232
49233   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49234   {
49235     try {
49236       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49237     } catch (std::out_of_range& e) {
49238       {
49239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49240       };
49241     } catch (std::exception& e) {
49242       {
49243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49244       };
49245     } catch (Dali::DaliException e) {
49246       {
49247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49248       };
49249     } catch (...) {
49250       {
49251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49252       };
49253     }
49254   }
49255
49256   jresult = (unsigned long)result;
49257   return jresult;
49258 }
49259
49260
49261 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49262   unsigned long jresult ;
49263   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49264   std::vector< Dali::TouchPoint >::size_type result;
49265
49266   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49267   {
49268     try {
49269       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49270     } catch (std::out_of_range& e) {
49271       {
49272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49273       };
49274     } catch (std::exception& e) {
49275       {
49276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49277       };
49278     } catch (Dali::DaliException e) {
49279       {
49280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49281       };
49282     } catch (...) {
49283       {
49284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49285       };
49286     }
49287   }
49288
49289   jresult = (unsigned long)result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49295   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49296   std::vector< Dali::TouchPoint >::size_type arg2 ;
49297
49298   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49299   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49300   {
49301     try {
49302       (arg1)->reserve(arg2);
49303     } catch (std::out_of_range& e) {
49304       {
49305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49306       };
49307     } catch (std::exception& e) {
49308       {
49309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (Dali::DaliException e) {
49312       {
49313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49314       };
49315     } catch (...) {
49316       {
49317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49318       };
49319     }
49320   }
49321
49322 }
49323
49324
49325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49326   void * jresult ;
49327   std::vector< Dali::TouchPoint > *result = 0 ;
49328
49329   {
49330     try {
49331       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49332     } catch (std::out_of_range& e) {
49333       {
49334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49335       };
49336     } catch (std::exception& e) {
49337       {
49338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49339       };
49340     } catch (Dali::DaliException e) {
49341       {
49342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49343       };
49344     } catch (...) {
49345       {
49346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49347       };
49348     }
49349   }
49350
49351   jresult = (void *)result;
49352   return jresult;
49353 }
49354
49355
49356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49357   void * jresult ;
49358   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49359   std::vector< Dali::TouchPoint > *result = 0 ;
49360
49361   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49362   if (!arg1) {
49363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49364     return 0;
49365   }
49366   {
49367     try {
49368       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49369     } catch (std::out_of_range& e) {
49370       {
49371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49372       };
49373     } catch (std::exception& e) {
49374       {
49375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49376       };
49377     } catch (Dali::DaliException e) {
49378       {
49379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49380       };
49381     } catch (...) {
49382       {
49383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49384       };
49385     }
49386   }
49387
49388   jresult = (void *)result;
49389   return jresult;
49390 }
49391
49392
49393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49394   void * jresult ;
49395   int arg1 ;
49396   std::vector< Dali::TouchPoint > *result = 0 ;
49397
49398   arg1 = (int)jarg1;
49399   {
49400     try {
49401       try {
49402         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49403       }
49404       catch(std::out_of_range &_e) {
49405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49406         return 0;
49407       }
49408
49409     } catch (std::out_of_range& e) {
49410       {
49411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49412       };
49413     } catch (std::exception& e) {
49414       {
49415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49416       };
49417     } catch (Dali::DaliException e) {
49418       {
49419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49420       };
49421     } catch (...) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49424       };
49425     }
49426   }
49427
49428   jresult = (void *)result;
49429   return jresult;
49430 }
49431
49432
49433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49434   void * jresult ;
49435   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49436   int arg2 ;
49437   SwigValueWrapper< Dali::TouchPoint > result;
49438
49439   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49440   arg2 = (int)jarg2;
49441   {
49442     try {
49443       try {
49444         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49445       }
49446       catch(std::out_of_range &_e) {
49447         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49448         return 0;
49449       }
49450
49451     } catch (std::out_of_range& e) {
49452       {
49453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49454       };
49455     } catch (std::exception& e) {
49456       {
49457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49458       };
49459     } catch (Dali::DaliException e) {
49460       {
49461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49462       };
49463     } catch (...) {
49464       {
49465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49466       };
49467     }
49468   }
49469
49470   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49471   return jresult;
49472 }
49473
49474
49475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49476   void * jresult ;
49477   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49478   int arg2 ;
49479   Dali::TouchPoint *result = 0 ;
49480
49481   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49482   arg2 = (int)jarg2;
49483   {
49484     try {
49485       try {
49486         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49487       }
49488       catch(std::out_of_range &_e) {
49489         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49490         return 0;
49491       }
49492
49493     } catch (std::out_of_range& e) {
49494       {
49495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49496       };
49497     } catch (std::exception& e) {
49498       {
49499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49500       };
49501     } catch (Dali::DaliException e) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49504       };
49505     } catch (...) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49508       };
49509     }
49510   }
49511
49512   jresult = (void *)result;
49513   return jresult;
49514 }
49515
49516
49517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49518   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49519   int arg2 ;
49520   Dali::TouchPoint *arg3 = 0 ;
49521
49522   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49523   arg2 = (int)jarg2;
49524   arg3 = (Dali::TouchPoint *)jarg3;
49525   if (!arg3) {
49526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49527     return ;
49528   }
49529   {
49530     try {
49531       try {
49532         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49533       }
49534       catch(std::out_of_range &_e) {
49535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49536         return ;
49537       }
49538
49539     } catch (std::out_of_range& e) {
49540       {
49541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49542       };
49543     } catch (std::exception& e) {
49544       {
49545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49546       };
49547     } catch (Dali::DaliException e) {
49548       {
49549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49550       };
49551     } catch (...) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49554       };
49555     }
49556   }
49557
49558 }
49559
49560
49561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49562   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49563   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49564
49565   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49566   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49567   if (!arg2) {
49568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49569     return ;
49570   }
49571   {
49572     try {
49573       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49574     } catch (std::out_of_range& e) {
49575       {
49576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49577       };
49578     } catch (std::exception& e) {
49579       {
49580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (Dali::DaliException e) {
49583       {
49584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49585       };
49586     } catch (...) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49589       };
49590     }
49591   }
49592
49593 }
49594
49595
49596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49597   void * jresult ;
49598   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49599   int arg2 ;
49600   int arg3 ;
49601   std::vector< Dali::TouchPoint > *result = 0 ;
49602
49603   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49604   arg2 = (int)jarg2;
49605   arg3 = (int)jarg3;
49606   {
49607     try {
49608       try {
49609         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49610       }
49611       catch(std::out_of_range &_e) {
49612         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49613         return 0;
49614       }
49615       catch(std::invalid_argument &_e) {
49616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49617         return 0;
49618       }
49619
49620     } catch (std::out_of_range& e) {
49621       {
49622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49623       };
49624     } catch (std::exception& e) {
49625       {
49626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (Dali::DaliException e) {
49629       {
49630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49631       };
49632     } catch (...) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49635       };
49636     }
49637   }
49638
49639   jresult = (void *)result;
49640   return jresult;
49641 }
49642
49643
49644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49645   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49646   int arg2 ;
49647   Dali::TouchPoint *arg3 = 0 ;
49648
49649   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49650   arg2 = (int)jarg2;
49651   arg3 = (Dali::TouchPoint *)jarg3;
49652   if (!arg3) {
49653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49654     return ;
49655   }
49656   {
49657     try {
49658       try {
49659         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49660       }
49661       catch(std::out_of_range &_e) {
49662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49663         return ;
49664       }
49665
49666     } catch (std::out_of_range& e) {
49667       {
49668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49669       };
49670     } catch (std::exception& e) {
49671       {
49672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49673       };
49674     } catch (Dali::DaliException e) {
49675       {
49676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49677       };
49678     } catch (...) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49681       };
49682     }
49683   }
49684
49685 }
49686
49687
49688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49689   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49690   int arg2 ;
49691   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49692
49693   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49694   arg2 = (int)jarg2;
49695   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49696   if (!arg3) {
49697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49698     return ;
49699   }
49700   {
49701     try {
49702       try {
49703         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49704       }
49705       catch(std::out_of_range &_e) {
49706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49707         return ;
49708       }
49709
49710     } catch (std::out_of_range& e) {
49711       {
49712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49713       };
49714     } catch (std::exception& e) {
49715       {
49716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49717       };
49718     } catch (Dali::DaliException e) {
49719       {
49720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49721       };
49722     } catch (...) {
49723       {
49724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49725       };
49726     }
49727   }
49728
49729 }
49730
49731
49732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49733   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49734   int arg2 ;
49735
49736   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49737   arg2 = (int)jarg2;
49738   {
49739     try {
49740       try {
49741         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49742       }
49743       catch(std::out_of_range &_e) {
49744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49745         return ;
49746       }
49747
49748     } catch (std::out_of_range& e) {
49749       {
49750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49751       };
49752     } catch (std::exception& e) {
49753       {
49754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49755       };
49756     } catch (Dali::DaliException e) {
49757       {
49758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49759       };
49760     } catch (...) {
49761       {
49762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49763       };
49764     }
49765   }
49766
49767 }
49768
49769
49770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49771   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49772   int arg2 ;
49773   int arg3 ;
49774
49775   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49776   arg2 = (int)jarg2;
49777   arg3 = (int)jarg3;
49778   {
49779     try {
49780       try {
49781         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49782       }
49783       catch(std::out_of_range &_e) {
49784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49785         return ;
49786       }
49787       catch(std::invalid_argument &_e) {
49788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49789         return ;
49790       }
49791
49792     } catch (std::out_of_range& e) {
49793       {
49794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49795       };
49796     } catch (std::exception& e) {
49797       {
49798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49799       };
49800     } catch (Dali::DaliException e) {
49801       {
49802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49803       };
49804     } catch (...) {
49805       {
49806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49807       };
49808     }
49809   }
49810
49811 }
49812
49813
49814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49815   void * jresult ;
49816   Dali::TouchPoint *arg1 = 0 ;
49817   int arg2 ;
49818   std::vector< Dali::TouchPoint > *result = 0 ;
49819
49820   arg1 = (Dali::TouchPoint *)jarg1;
49821   if (!arg1) {
49822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49823     return 0;
49824   }
49825   arg2 = (int)jarg2;
49826   {
49827     try {
49828       try {
49829         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49830       }
49831       catch(std::out_of_range &_e) {
49832         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49833         return 0;
49834       }
49835
49836     } catch (std::out_of_range& e) {
49837       {
49838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49839       };
49840     } catch (std::exception& e) {
49841       {
49842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49843       };
49844     } catch (Dali::DaliException e) {
49845       {
49846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49847       };
49848     } catch (...) {
49849       {
49850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49851       };
49852     }
49853   }
49854
49855   jresult = (void *)result;
49856   return jresult;
49857 }
49858
49859
49860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49861   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49862
49863   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49864   {
49865     try {
49866       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49867     } catch (std::out_of_range& e) {
49868       {
49869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49870       };
49871     } catch (std::exception& e) {
49872       {
49873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49874       };
49875     } catch (Dali::DaliException e) {
49876       {
49877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49878       };
49879     } catch (...) {
49880       {
49881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49882       };
49883     }
49884   }
49885
49886 }
49887
49888
49889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49890   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49891   int arg2 ;
49892   int arg3 ;
49893
49894   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49895   arg2 = (int)jarg2;
49896   arg3 = (int)jarg3;
49897   {
49898     try {
49899       try {
49900         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49901       }
49902       catch(std::out_of_range &_e) {
49903         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49904         return ;
49905       }
49906       catch(std::invalid_argument &_e) {
49907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49908         return ;
49909       }
49910
49911     } catch (std::out_of_range& e) {
49912       {
49913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49914       };
49915     } catch (std::exception& e) {
49916       {
49917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49918       };
49919     } catch (Dali::DaliException e) {
49920       {
49921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49922       };
49923     } catch (...) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49926       };
49927     }
49928   }
49929
49930 }
49931
49932
49933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49934   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49935   int arg2 ;
49936   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49937
49938   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49939   arg2 = (int)jarg2;
49940   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49941   if (!arg3) {
49942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49943     return ;
49944   }
49945   {
49946     try {
49947       try {
49948         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49949       }
49950       catch(std::out_of_range &_e) {
49951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49952         return ;
49953       }
49954
49955     } catch (std::out_of_range& e) {
49956       {
49957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49958       };
49959     } catch (std::exception& e) {
49960       {
49961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (Dali::DaliException e) {
49964       {
49965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49966       };
49967     } catch (...) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49970       };
49971     }
49972   }
49973
49974 }
49975
49976
49977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49978   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49979
49980   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49981   {
49982     try {
49983       delete arg1;
49984     } catch (std::out_of_range& e) {
49985       {
49986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49987       };
49988     } catch (std::exception& e) {
49989       {
49990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49991       };
49992     } catch (Dali::DaliException e) {
49993       {
49994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49995       };
49996     } catch (...) {
49997       {
49998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49999       };
50000     }
50001   }
50002
50003 }
50004
50005
50006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50007   void * jresult ;
50008   Dali::Rect< int > *result = 0 ;
50009
50010   {
50011     try {
50012       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50013     } catch (std::out_of_range& e) {
50014       {
50015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50016       };
50017     } catch (std::exception& e) {
50018       {
50019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50020       };
50021     } catch (Dali::DaliException e) {
50022       {
50023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50024       };
50025     } catch (...) {
50026       {
50027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50028       };
50029     }
50030   }
50031
50032   jresult = (void *)result;
50033   return jresult;
50034 }
50035
50036
50037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50038   void * jresult ;
50039   int arg1 ;
50040   int arg2 ;
50041   int arg3 ;
50042   int arg4 ;
50043   Dali::Rect< int > *result = 0 ;
50044
50045   arg1 = (int)jarg1;
50046   arg2 = (int)jarg2;
50047   arg3 = (int)jarg3;
50048   arg4 = (int)jarg4;
50049   {
50050     try {
50051       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50052     } catch (std::out_of_range& e) {
50053       {
50054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50055       };
50056     } catch (std::exception& e) {
50057       {
50058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50059       };
50060     } catch (Dali::DaliException e) {
50061       {
50062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50063       };
50064     } catch (...) {
50065       {
50066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50067       };
50068     }
50069   }
50070
50071   jresult = (void *)result;
50072   return jresult;
50073 }
50074
50075
50076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50077   void * jresult ;
50078   Dali::Rect< int > *arg1 = 0 ;
50079   Dali::Rect< int > *result = 0 ;
50080
50081   arg1 = (Dali::Rect< int > *)jarg1;
50082   if (!arg1) {
50083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50084     return 0;
50085   }
50086   {
50087     try {
50088       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50089     } catch (std::out_of_range& e) {
50090       {
50091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50092       };
50093     } catch (std::exception& e) {
50094       {
50095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50096       };
50097     } catch (Dali::DaliException e) {
50098       {
50099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50100       };
50101     } catch (...) {
50102       {
50103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50104       };
50105     }
50106   }
50107
50108   jresult = (void *)result;
50109   return jresult;
50110 }
50111
50112
50113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50114   void * jresult ;
50115   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50116   Dali::Rect< int > *arg2 = 0 ;
50117   Dali::Rect< int > *result = 0 ;
50118
50119   arg1 = (Dali::Rect< int > *)jarg1;
50120   arg2 = (Dali::Rect< int > *)jarg2;
50121   if (!arg2) {
50122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50123     return 0;
50124   }
50125   {
50126     try {
50127       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50128     } catch (std::out_of_range& e) {
50129       {
50130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50131       };
50132     } catch (std::exception& e) {
50133       {
50134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50135       };
50136     } catch (Dali::DaliException e) {
50137       {
50138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50139       };
50140     } catch (...) {
50141       {
50142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50143       };
50144     }
50145   }
50146
50147   jresult = (void *)result;
50148   return jresult;
50149 }
50150
50151
50152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50153   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50154   int arg2 ;
50155   int arg3 ;
50156   int arg4 ;
50157   int arg5 ;
50158
50159   arg1 = (Dali::Rect< int > *)jarg1;
50160   arg2 = (int)jarg2;
50161   arg3 = (int)jarg3;
50162   arg4 = (int)jarg4;
50163   arg5 = (int)jarg5;
50164   {
50165     try {
50166       (arg1)->Set(arg2,arg3,arg4,arg5);
50167     } catch (std::out_of_range& e) {
50168       {
50169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50170       };
50171     } catch (std::exception& e) {
50172       {
50173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50174       };
50175     } catch (Dali::DaliException e) {
50176       {
50177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50178       };
50179     } catch (...) {
50180       {
50181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50182       };
50183     }
50184   }
50185
50186 }
50187
50188
50189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50190   unsigned int jresult ;
50191   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50192   bool result;
50193
50194   arg1 = (Dali::Rect< int > *)jarg1;
50195   {
50196     try {
50197       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50198     } catch (std::out_of_range& e) {
50199       {
50200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50201       };
50202     } catch (std::exception& e) {
50203       {
50204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50205       };
50206     } catch (Dali::DaliException e) {
50207       {
50208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50209       };
50210     } catch (...) {
50211       {
50212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50213       };
50214     }
50215   }
50216
50217   jresult = result;
50218   return jresult;
50219 }
50220
50221
50222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50223   int jresult ;
50224   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50225   int result;
50226
50227   arg1 = (Dali::Rect< int > *)jarg1;
50228   {
50229     try {
50230       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50231     } catch (std::out_of_range& e) {
50232       {
50233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50234       };
50235     } catch (std::exception& e) {
50236       {
50237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50238       };
50239     } catch (Dali::DaliException e) {
50240       {
50241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50242       };
50243     } catch (...) {
50244       {
50245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50246       };
50247     }
50248   }
50249
50250   jresult = result;
50251   return jresult;
50252 }
50253
50254
50255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50256   int jresult ;
50257   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50258   int result;
50259
50260   arg1 = (Dali::Rect< int > *)jarg1;
50261   {
50262     try {
50263       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50264     } catch (std::out_of_range& e) {
50265       {
50266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50267       };
50268     } catch (std::exception& e) {
50269       {
50270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50271       };
50272     } catch (Dali::DaliException e) {
50273       {
50274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50275       };
50276     } catch (...) {
50277       {
50278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50279       };
50280     }
50281   }
50282
50283   jresult = result;
50284   return jresult;
50285 }
50286
50287
50288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50289   int jresult ;
50290   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50291   int result;
50292
50293   arg1 = (Dali::Rect< int > *)jarg1;
50294   {
50295     try {
50296       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50297     } catch (std::out_of_range& e) {
50298       {
50299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50300       };
50301     } catch (std::exception& e) {
50302       {
50303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50304       };
50305     } catch (Dali::DaliException e) {
50306       {
50307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50308       };
50309     } catch (...) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50312       };
50313     }
50314   }
50315
50316   jresult = result;
50317   return jresult;
50318 }
50319
50320
50321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50322   int jresult ;
50323   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50324   int result;
50325
50326   arg1 = (Dali::Rect< int > *)jarg1;
50327   {
50328     try {
50329       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50330     } catch (std::out_of_range& e) {
50331       {
50332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50333       };
50334     } catch (std::exception& e) {
50335       {
50336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50337       };
50338     } catch (Dali::DaliException e) {
50339       {
50340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50341       };
50342     } catch (...) {
50343       {
50344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50345       };
50346     }
50347   }
50348
50349   jresult = result;
50350   return jresult;
50351 }
50352
50353
50354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50355   int jresult ;
50356   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50357   int result;
50358
50359   arg1 = (Dali::Rect< int > *)jarg1;
50360   {
50361     try {
50362       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50363     } catch (std::out_of_range& e) {
50364       {
50365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50366       };
50367     } catch (std::exception& e) {
50368       {
50369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (Dali::DaliException e) {
50372       {
50373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381
50382   jresult = result;
50383   return jresult;
50384 }
50385
50386
50387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50388   unsigned int jresult ;
50389   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50390   Dali::Rect< int > *arg2 = 0 ;
50391   bool result;
50392
50393   arg1 = (Dali::Rect< int > *)jarg1;
50394   arg2 = (Dali::Rect< int > *)jarg2;
50395   if (!arg2) {
50396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50397     return 0;
50398   }
50399   {
50400     try {
50401       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50402     } catch (std::out_of_range& e) {
50403       {
50404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50405       };
50406     } catch (std::exception& e) {
50407       {
50408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50409       };
50410     } catch (Dali::DaliException e) {
50411       {
50412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50413       };
50414     } catch (...) {
50415       {
50416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50417       };
50418     }
50419   }
50420
50421   jresult = result;
50422   return jresult;
50423 }
50424
50425
50426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50427   unsigned int jresult ;
50428   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50429   Dali::Rect< int > *arg2 = 0 ;
50430   bool result;
50431
50432   arg1 = (Dali::Rect< int > *)jarg1;
50433   arg2 = (Dali::Rect< int > *)jarg2;
50434   if (!arg2) {
50435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50436     return 0;
50437   }
50438   {
50439     try {
50440       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50441     } catch (std::out_of_range& e) {
50442       {
50443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50444       };
50445     } catch (std::exception& e) {
50446       {
50447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50448       };
50449     } catch (Dali::DaliException e) {
50450       {
50451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50452       };
50453     } catch (...) {
50454       {
50455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50456       };
50457     }
50458   }
50459
50460   jresult = result;
50461   return jresult;
50462 }
50463
50464
50465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50466   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50467   int arg2 ;
50468
50469   arg1 = (Dali::Rect< int > *)jarg1;
50470   arg2 = (int)jarg2;
50471   if (arg1) (arg1)->x = arg2;
50472 }
50473
50474
50475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50476   int jresult ;
50477   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50478   int result;
50479
50480   arg1 = (Dali::Rect< int > *)jarg1;
50481   result = (int) ((arg1)->x);
50482   jresult = result;
50483   return jresult;
50484 }
50485
50486
50487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50488   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50489   int arg2 ;
50490
50491   arg1 = (Dali::Rect< int > *)jarg1;
50492   arg2 = (int)jarg2;
50493   if (arg1) (arg1)->left = arg2;
50494 }
50495
50496
50497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50498   int jresult ;
50499   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50500   int result;
50501
50502   arg1 = (Dali::Rect< int > *)jarg1;
50503   result = (int) ((arg1)->left);
50504   jresult = result;
50505   return jresult;
50506 }
50507
50508
50509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50510   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50511   int arg2 ;
50512
50513   arg1 = (Dali::Rect< int > *)jarg1;
50514   arg2 = (int)jarg2;
50515   if (arg1) (arg1)->y = arg2;
50516 }
50517
50518
50519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50520   int jresult ;
50521   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50522   int result;
50523
50524   arg1 = (Dali::Rect< int > *)jarg1;
50525   result = (int) ((arg1)->y);
50526   jresult = result;
50527   return jresult;
50528 }
50529
50530
50531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50532   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50533   int arg2 ;
50534
50535   arg1 = (Dali::Rect< int > *)jarg1;
50536   arg2 = (int)jarg2;
50537   if (arg1) (arg1)->right = arg2;
50538 }
50539
50540
50541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50542   int jresult ;
50543   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50544   int result;
50545
50546   arg1 = (Dali::Rect< int > *)jarg1;
50547   result = (int) ((arg1)->right);
50548   jresult = result;
50549   return jresult;
50550 }
50551
50552
50553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50554   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50555   int arg2 ;
50556
50557   arg1 = (Dali::Rect< int > *)jarg1;
50558   arg2 = (int)jarg2;
50559   if (arg1) (arg1)->width = arg2;
50560 }
50561
50562
50563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50564   int jresult ;
50565   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50566   int result;
50567
50568   arg1 = (Dali::Rect< int > *)jarg1;
50569   result = (int) ((arg1)->width);
50570   jresult = result;
50571   return jresult;
50572 }
50573
50574
50575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50576   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50577   int arg2 ;
50578
50579   arg1 = (Dali::Rect< int > *)jarg1;
50580   arg2 = (int)jarg2;
50581   if (arg1) (arg1)->bottom = arg2;
50582 }
50583
50584
50585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50586   int jresult ;
50587   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50588   int result;
50589
50590   arg1 = (Dali::Rect< int > *)jarg1;
50591   result = (int) ((arg1)->bottom);
50592   jresult = result;
50593   return jresult;
50594 }
50595
50596
50597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50598   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50599   int arg2 ;
50600
50601   arg1 = (Dali::Rect< int > *)jarg1;
50602   arg2 = (int)jarg2;
50603   if (arg1) (arg1)->height = arg2;
50604 }
50605
50606
50607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50608   int jresult ;
50609   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50610   int result;
50611
50612   arg1 = (Dali::Rect< int > *)jarg1;
50613   result = (int) ((arg1)->height);
50614   jresult = result;
50615   return jresult;
50616 }
50617
50618
50619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50620   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50621   int arg2 ;
50622
50623   arg1 = (Dali::Rect< int > *)jarg1;
50624   arg2 = (int)jarg2;
50625   if (arg1) (arg1)->top = arg2;
50626 }
50627
50628
50629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50630   int jresult ;
50631   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50632   int result;
50633
50634   arg1 = (Dali::Rect< int > *)jarg1;
50635   result = (int) ((arg1)->top);
50636   jresult = result;
50637   return jresult;
50638 }
50639
50640
50641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50642   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50643
50644   arg1 = (Dali::Rect< int > *)jarg1;
50645   {
50646     try {
50647       delete arg1;
50648     } catch (std::out_of_range& e) {
50649       {
50650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50651       };
50652     } catch (std::exception& e) {
50653       {
50654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50655       };
50656     } catch (Dali::DaliException e) {
50657       {
50658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50659       };
50660     } catch (...) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50663       };
50664     }
50665   }
50666
50667 }
50668
50669
50670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50671   void * jresult ;
50672   Dali::Rect< float > *result = 0 ;
50673
50674   {
50675     try {
50676       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50677     } catch (std::out_of_range& e) {
50678       {
50679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50680       };
50681     } catch (std::exception& e) {
50682       {
50683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50684       };
50685     } catch (Dali::DaliException e) {
50686       {
50687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50688       };
50689     } catch (...) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50692       };
50693     }
50694   }
50695
50696   jresult = (void *)result;
50697   return jresult;
50698 }
50699
50700
50701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50702   void * jresult ;
50703   float arg1 ;
50704   float arg2 ;
50705   float arg3 ;
50706   float arg4 ;
50707   Dali::Rect< float > *result = 0 ;
50708
50709   arg1 = (float)jarg1;
50710   arg2 = (float)jarg2;
50711   arg3 = (float)jarg4;
50712   arg4 = (float)jarg3;
50713   {
50714     try {
50715       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50716     } catch (std::out_of_range& e) {
50717       {
50718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50719       };
50720     } catch (std::exception& e) {
50721       {
50722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50723       };
50724     } catch (Dali::DaliException e) {
50725       {
50726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50727       };
50728     } catch (...) {
50729       {
50730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50731       };
50732     }
50733   }
50734
50735   jresult = (void *)result;
50736   return jresult;
50737 }
50738
50739
50740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50741   void * jresult ;
50742   Dali::Rect< float > *arg1 = 0 ;
50743   Dali::Rect< float > *result = 0 ;
50744
50745   arg1 = (Dali::Rect< float > *)jarg1;
50746   if (!arg1) {
50747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50748     return 0;
50749   }
50750   {
50751     try {
50752       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50753     } catch (std::out_of_range& e) {
50754       {
50755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50756       };
50757     } catch (std::exception& e) {
50758       {
50759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50760       };
50761     } catch (Dali::DaliException e) {
50762       {
50763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50764       };
50765     } catch (...) {
50766       {
50767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50768       };
50769     }
50770   }
50771
50772   jresult = (void *)result;
50773   return jresult;
50774 }
50775
50776
50777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50778   void * jresult ;
50779   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50780   Dali::Rect< float > *arg2 = 0 ;
50781   Dali::Rect< float > *result = 0 ;
50782
50783   arg1 = (Dali::Rect< float > *)jarg1;
50784   arg2 = (Dali::Rect< float > *)jarg2;
50785   if (!arg2) {
50786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50787     return 0;
50788   }
50789   {
50790     try {
50791       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50792     } catch (std::out_of_range& e) {
50793       {
50794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50795       };
50796     } catch (std::exception& e) {
50797       {
50798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50799       };
50800     } catch (Dali::DaliException e) {
50801       {
50802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50803       };
50804     } catch (...) {
50805       {
50806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50807       };
50808     }
50809   }
50810
50811   jresult = (void *)result;
50812   return jresult;
50813 }
50814
50815
50816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50817   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50818   float arg2 ;
50819   float arg3 ;
50820   float arg4 ;
50821   float arg5 ;
50822
50823   arg1 = (Dali::Rect< float > *)jarg1;
50824   arg2 = (float)jarg2;
50825   arg3 = (float)jarg3;
50826   arg4 = (float)jarg5;
50827   arg5 = (float)jarg4;
50828   {
50829     try {
50830       (arg1)->Set(arg2,arg3,arg4,arg5);
50831     } catch (std::out_of_range& e) {
50832       {
50833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50834       };
50835     } catch (std::exception& e) {
50836       {
50837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50838       };
50839     } catch (Dali::DaliException e) {
50840       {
50841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50842       };
50843     } catch (...) {
50844       {
50845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50846       };
50847     }
50848   }
50849
50850 }
50851
50852
50853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50854   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50855   float arg2 ;
50856
50857   arg1 = (Dali::Rect< float > *)jarg1;
50858   arg2 = (float)jarg2;
50859   if (arg1) (arg1)->left = arg2;
50860 }
50861
50862
50863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50864   float jresult ;
50865   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50866   float result;
50867
50868   arg1 = (Dali::Rect< float > *)jarg1;
50869   result = (float) ((arg1)->left);
50870   jresult = result;
50871   return jresult;
50872 }
50873
50874
50875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50876   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50877   float arg2 ;
50878
50879   arg1 = (Dali::Rect< float > *)jarg1;
50880   arg2 = (float)jarg2;
50881   if (arg1) (arg1)->left = arg2;
50882 }
50883
50884
50885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50886   float jresult ;
50887   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50888   float result;
50889
50890   arg1 = (Dali::Rect< float > *)jarg1;
50891   result = (float) ((arg1)->left);
50892   jresult = result;
50893   return jresult;
50894 }
50895
50896
50897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50898   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50899   float arg2 ;
50900
50901   arg1 = (Dali::Rect< float > *)jarg1;
50902   arg2 = (float)jarg2;
50903   if (arg1) (arg1)->right = arg2;
50904 }
50905
50906
50907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50908   float jresult ;
50909   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50910   float result;
50911
50912   arg1 = (Dali::Rect< float > *)jarg1;
50913   result = (float) ((arg1)->right);
50914   jresult = result;
50915   return jresult;
50916 }
50917
50918
50919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50920   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50921   float arg2 ;
50922
50923   arg1 = (Dali::Rect< float > *)jarg1;
50924   arg2 = (float)jarg2;
50925   if (arg1) (arg1)->right = arg2;
50926 }
50927
50928
50929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50930   float jresult ;
50931   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50932   float result;
50933
50934   arg1 = (Dali::Rect< float > *)jarg1;
50935   result = (float) ((arg1)->right);
50936   jresult = result;
50937   return jresult;
50938 }
50939
50940
50941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50942   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50943   float arg2 ;
50944
50945   arg1 = (Dali::Rect< float > *)jarg1;
50946   arg2 = (float)jarg2;
50947   if (arg1) (arg1)->bottom = arg2;
50948 }
50949
50950
50951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50952   float jresult ;
50953   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50954   float result;
50955
50956   arg1 = (Dali::Rect< float > *)jarg1;
50957   result = (float) ((arg1)->bottom);
50958   jresult = result;
50959   return jresult;
50960 }
50961
50962
50963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50964   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50965   float arg2 ;
50966
50967   arg1 = (Dali::Rect< float > *)jarg1;
50968   arg2 = (float)jarg2;
50969   if (arg1) (arg1)->top = arg2;
50970 }
50971
50972
50973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50974   float jresult ;
50975   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50976   float result;
50977
50978   arg1 = (Dali::Rect< float > *)jarg1;
50979   result = (float) ((arg1)->top);
50980   jresult = result;
50981   return jresult;
50982 }
50983
50984
50985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50986   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50987
50988   arg1 = (Dali::Rect< float > *)jarg1;
50989   {
50990     try {
50991       delete arg1;
50992     } catch (std::out_of_range& e) {
50993       {
50994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50995       };
50996     } catch (std::exception& e) {
50997       {
50998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (Dali::DaliException e) {
51001       {
51002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51003       };
51004     } catch (...) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51007       };
51008     }
51009   }
51010
51011 }
51012
51013
51014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51015   int jresult ;
51016   int result;
51017
51018   result = (int)Dali::Vector< int >::BaseType;
51019   jresult = (int)result;
51020   return jresult;
51021 }
51022
51023
51024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51025   void * jresult ;
51026   Dali::Vector< int > *result = 0 ;
51027
51028   {
51029     try {
51030       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51031     } catch (std::out_of_range& e) {
51032       {
51033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51034       };
51035     } catch (std::exception& e) {
51036       {
51037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51038       };
51039     } catch (Dali::DaliException e) {
51040       {
51041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51042       };
51043     } catch (...) {
51044       {
51045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51046       };
51047     }
51048   }
51049
51050   jresult = (void *)result;
51051   return jresult;
51052 }
51053
51054
51055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51056   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51057
51058   arg1 = (Dali::Vector< int > *)jarg1;
51059   {
51060     try {
51061       delete arg1;
51062     } catch (std::out_of_range& e) {
51063       {
51064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51065       };
51066     } catch (std::exception& e) {
51067       {
51068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51069       };
51070     } catch (Dali::DaliException e) {
51071       {
51072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51073       };
51074     } catch (...) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51077       };
51078     }
51079   }
51080
51081 }
51082
51083
51084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51085   void * jresult ;
51086   Dali::Vector< int > *arg1 = 0 ;
51087   Dali::Vector< int > *result = 0 ;
51088
51089   arg1 = (Dali::Vector< int > *)jarg1;
51090   if (!arg1) {
51091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51092     return 0;
51093   }
51094   {
51095     try {
51096       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51097     } catch (std::out_of_range& e) {
51098       {
51099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51100       };
51101     } catch (std::exception& e) {
51102       {
51103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51104       };
51105     } catch (Dali::DaliException e) {
51106       {
51107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51108       };
51109     } catch (...) {
51110       {
51111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51112       };
51113     }
51114   }
51115
51116   jresult = (void *)result;
51117   return jresult;
51118 }
51119
51120
51121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51122   void * jresult ;
51123   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51124   Dali::Vector< int > *arg2 = 0 ;
51125   Dali::Vector< int > *result = 0 ;
51126
51127   arg1 = (Dali::Vector< int > *)jarg1;
51128   arg2 = (Dali::Vector< int > *)jarg2;
51129   if (!arg2) {
51130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51131     return 0;
51132   }
51133   {
51134     try {
51135       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51136     } catch (std::out_of_range& e) {
51137       {
51138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51139       };
51140     } catch (std::exception& e) {
51141       {
51142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51143       };
51144     } catch (Dali::DaliException e) {
51145       {
51146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51147       };
51148     } catch (...) {
51149       {
51150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51151       };
51152     }
51153   }
51154
51155   jresult = (void *)result;
51156   return jresult;
51157 }
51158
51159
51160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51161   void * jresult ;
51162   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51163   Dali::Vector< int >::Iterator result;
51164
51165   arg1 = (Dali::Vector< int > *)jarg1;
51166   {
51167     try {
51168       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51169     } catch (std::out_of_range& e) {
51170       {
51171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51172       };
51173     } catch (std::exception& e) {
51174       {
51175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51176       };
51177     } catch (Dali::DaliException e) {
51178       {
51179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51180       };
51181     } catch (...) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51184       };
51185     }
51186   }
51187
51188   jresult = (void *)result;
51189   return jresult;
51190 }
51191
51192
51193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51194   void * jresult ;
51195   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51196   Dali::Vector< int >::Iterator result;
51197
51198   arg1 = (Dali::Vector< int > *)jarg1;
51199   {
51200     try {
51201       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51202     } catch (std::out_of_range& e) {
51203       {
51204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51205       };
51206     } catch (std::exception& e) {
51207       {
51208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51209       };
51210     } catch (Dali::DaliException e) {
51211       {
51212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51213       };
51214     } catch (...) {
51215       {
51216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51217       };
51218     }
51219   }
51220
51221   jresult = (void *)result;
51222   return jresult;
51223 }
51224
51225
51226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51227   void * jresult ;
51228   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51229   Dali::Vector< int >::SizeType arg2 ;
51230   Dali::Vector< int >::ItemType *result = 0 ;
51231
51232   arg1 = (Dali::Vector< int > *)jarg1;
51233   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51234   {
51235     try {
51236       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51237     } catch (std::out_of_range& e) {
51238       {
51239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51240       };
51241     } catch (std::exception& e) {
51242       {
51243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51244       };
51245     } catch (Dali::DaliException e) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51248       };
51249     } catch (...) {
51250       {
51251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51252       };
51253     }
51254   }
51255
51256   jresult = (void *)result;
51257   return jresult;
51258 }
51259
51260
51261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51262   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51263   Dali::Vector< int >::ItemType *arg2 = 0 ;
51264   Dali::Vector< int >::ItemType temp2 ;
51265
51266   arg1 = (Dali::Vector< int > *)jarg1;
51267   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51268   arg2 = &temp2;
51269   {
51270     try {
51271       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51272     } catch (std::out_of_range& e) {
51273       {
51274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51275       };
51276     } catch (std::exception& e) {
51277       {
51278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51279       };
51280     } catch (Dali::DaliException e) {
51281       {
51282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51283       };
51284     } catch (...) {
51285       {
51286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51287       };
51288     }
51289   }
51290
51291 }
51292
51293
51294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51295   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51296   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51297   Dali::Vector< int >::ItemType *arg3 = 0 ;
51298   Dali::Vector< int >::ItemType temp3 ;
51299
51300   arg1 = (Dali::Vector< int > *)jarg1;
51301   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51302   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51303   arg3 = &temp3;
51304   {
51305     try {
51306       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51307     } catch (std::out_of_range& e) {
51308       {
51309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51310       };
51311     } catch (std::exception& e) {
51312       {
51313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51314       };
51315     } catch (Dali::DaliException e) {
51316       {
51317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51318       };
51319     } catch (...) {
51320       {
51321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51322       };
51323     }
51324   }
51325
51326 }
51327
51328
51329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51330   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51331   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51332   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51333   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51334
51335   arg1 = (Dali::Vector< int > *)jarg1;
51336   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51337   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51338   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51339   {
51340     try {
51341       (arg1)->Insert(arg2,arg3,arg4);
51342     } catch (std::out_of_range& e) {
51343       {
51344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51345       };
51346     } catch (std::exception& e) {
51347       {
51348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51349       };
51350     } catch (Dali::DaliException e) {
51351       {
51352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51353       };
51354     } catch (...) {
51355       {
51356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51357       };
51358     }
51359   }
51360
51361 }
51362
51363
51364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51365   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51366   Dali::Vector< int >::SizeType arg2 ;
51367
51368   arg1 = (Dali::Vector< int > *)jarg1;
51369   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51370   {
51371     try {
51372       (arg1)->Reserve(arg2);
51373     } catch (std::out_of_range& e) {
51374       {
51375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51376       };
51377     } catch (std::exception& e) {
51378       {
51379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51380       };
51381     } catch (Dali::DaliException e) {
51382       {
51383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51384       };
51385     } catch (...) {
51386       {
51387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51388       };
51389     }
51390   }
51391
51392 }
51393
51394
51395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51396   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51397   Dali::Vector< int >::SizeType arg2 ;
51398
51399   arg1 = (Dali::Vector< int > *)jarg1;
51400   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51401   {
51402     try {
51403       (arg1)->Resize(arg2);
51404     } catch (std::out_of_range& e) {
51405       {
51406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51407       };
51408     } catch (std::exception& e) {
51409       {
51410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51411       };
51412     } catch (Dali::DaliException e) {
51413       {
51414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51415       };
51416     } catch (...) {
51417       {
51418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51419       };
51420     }
51421   }
51422
51423 }
51424
51425
51426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51427   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51428   Dali::Vector< int >::SizeType arg2 ;
51429   Dali::Vector< int >::ItemType *arg3 = 0 ;
51430   Dali::Vector< int >::ItemType temp3 ;
51431
51432   arg1 = (Dali::Vector< int > *)jarg1;
51433   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51434   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51435   arg3 = &temp3;
51436   {
51437     try {
51438       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51439     } catch (std::out_of_range& e) {
51440       {
51441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51442       };
51443     } catch (std::exception& e) {
51444       {
51445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51446       };
51447     } catch (Dali::DaliException e) {
51448       {
51449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51450       };
51451     } catch (...) {
51452       {
51453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51454       };
51455     }
51456   }
51457
51458 }
51459
51460
51461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51462   void * jresult ;
51463   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51464   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51465   Dali::Vector< int >::Iterator result;
51466
51467   arg1 = (Dali::Vector< int > *)jarg1;
51468   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51469   {
51470     try {
51471       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51472     } catch (std::out_of_range& e) {
51473       {
51474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51475       };
51476     } catch (std::exception& e) {
51477       {
51478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51479       };
51480     } catch (Dali::DaliException e) {
51481       {
51482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51483       };
51484     } catch (...) {
51485       {
51486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51487       };
51488     }
51489   }
51490
51491   jresult = (void *)result;
51492   return jresult;
51493 }
51494
51495
51496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51497   void * jresult ;
51498   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51499   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51500   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51501   Dali::Vector< int >::Iterator result;
51502
51503   arg1 = (Dali::Vector< int > *)jarg1;
51504   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51505   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51506   {
51507     try {
51508       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51509     } catch (std::out_of_range& e) {
51510       {
51511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51512       };
51513     } catch (std::exception& e) {
51514       {
51515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51516       };
51517     } catch (Dali::DaliException e) {
51518       {
51519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51520       };
51521     } catch (...) {
51522       {
51523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51524       };
51525     }
51526   }
51527
51528   jresult = (void *)result;
51529   return jresult;
51530 }
51531
51532
51533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51534   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51535   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51536
51537   arg1 = (Dali::Vector< int > *)jarg1;
51538   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51539   {
51540     try {
51541       (arg1)->Remove(arg2);
51542     } catch (std::out_of_range& e) {
51543       {
51544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51545       };
51546     } catch (std::exception& e) {
51547       {
51548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51549       };
51550     } catch (Dali::DaliException e) {
51551       {
51552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51553       };
51554     } catch (...) {
51555       {
51556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51557       };
51558     }
51559   }
51560
51561 }
51562
51563
51564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51565   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51566   Dali::Vector< int > *arg2 = 0 ;
51567
51568   arg1 = (Dali::Vector< int > *)jarg1;
51569   arg2 = (Dali::Vector< int > *)jarg2;
51570   if (!arg2) {
51571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51572     return ;
51573   }
51574   {
51575     try {
51576       (arg1)->Swap(*arg2);
51577     } catch (std::out_of_range& e) {
51578       {
51579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51580       };
51581     } catch (std::exception& e) {
51582       {
51583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51584       };
51585     } catch (Dali::DaliException e) {
51586       {
51587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51588       };
51589     } catch (...) {
51590       {
51591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51592       };
51593     }
51594   }
51595
51596 }
51597
51598
51599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51600   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51601
51602   arg1 = (Dali::Vector< int > *)jarg1;
51603   {
51604     try {
51605       (arg1)->Clear();
51606     } catch (std::out_of_range& e) {
51607       {
51608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51609       };
51610     } catch (std::exception& e) {
51611       {
51612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51613       };
51614     } catch (Dali::DaliException e) {
51615       {
51616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51617       };
51618     } catch (...) {
51619       {
51620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51621       };
51622     }
51623   }
51624
51625 }
51626
51627
51628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51629   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51630
51631   arg1 = (Dali::Vector< int > *)jarg1;
51632   {
51633     try {
51634       (arg1)->Release();
51635     } catch (std::out_of_range& e) {
51636       {
51637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51638       };
51639     } catch (std::exception& e) {
51640       {
51641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51642       };
51643     } catch (Dali::DaliException e) {
51644       {
51645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51646       };
51647     } catch (...) {
51648       {
51649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51650       };
51651     }
51652   }
51653
51654 }
51655
51656
51657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51658   int jresult ;
51659   int result;
51660
51661   result = (int)Dali::Vector< float >::BaseType;
51662   jresult = (int)result;
51663   return jresult;
51664 }
51665
51666
51667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51668   void * jresult ;
51669   Dali::Vector< float > *result = 0 ;
51670
51671   {
51672     try {
51673       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51674     } catch (std::out_of_range& e) {
51675       {
51676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51677       };
51678     } catch (std::exception& e) {
51679       {
51680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (Dali::DaliException e) {
51683       {
51684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51685       };
51686     } catch (...) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51689       };
51690     }
51691   }
51692
51693   jresult = (void *)result;
51694   return jresult;
51695 }
51696
51697
51698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51699   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51700
51701   arg1 = (Dali::Vector< float > *)jarg1;
51702   {
51703     try {
51704       delete arg1;
51705     } catch (std::out_of_range& e) {
51706       {
51707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51708       };
51709     } catch (std::exception& e) {
51710       {
51711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51712       };
51713     } catch (Dali::DaliException e) {
51714       {
51715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51716       };
51717     } catch (...) {
51718       {
51719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51720       };
51721     }
51722   }
51723
51724 }
51725
51726
51727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51728   void * jresult ;
51729   Dali::Vector< float > *arg1 = 0 ;
51730   Dali::Vector< float > *result = 0 ;
51731
51732   arg1 = (Dali::Vector< float > *)jarg1;
51733   if (!arg1) {
51734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51735     return 0;
51736   }
51737   {
51738     try {
51739       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51740     } catch (std::out_of_range& e) {
51741       {
51742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51743       };
51744     } catch (std::exception& e) {
51745       {
51746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51747       };
51748     } catch (Dali::DaliException e) {
51749       {
51750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51751       };
51752     } catch (...) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51755       };
51756     }
51757   }
51758
51759   jresult = (void *)result;
51760   return jresult;
51761 }
51762
51763
51764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51765   void * jresult ;
51766   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51767   Dali::Vector< float > *arg2 = 0 ;
51768   Dali::Vector< float > *result = 0 ;
51769
51770   arg1 = (Dali::Vector< float > *)jarg1;
51771   arg2 = (Dali::Vector< float > *)jarg2;
51772   if (!arg2) {
51773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51774     return 0;
51775   }
51776   {
51777     try {
51778       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51779     } catch (std::out_of_range& e) {
51780       {
51781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51782       };
51783     } catch (std::exception& e) {
51784       {
51785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51786       };
51787     } catch (Dali::DaliException e) {
51788       {
51789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51790       };
51791     } catch (...) {
51792       {
51793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51794       };
51795     }
51796   }
51797
51798   jresult = (void *)result;
51799   return jresult;
51800 }
51801
51802
51803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51804   void * jresult ;
51805   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51806   Dali::Vector< float >::Iterator result;
51807
51808   arg1 = (Dali::Vector< float > *)jarg1;
51809   {
51810     try {
51811       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51812     } catch (std::out_of_range& e) {
51813       {
51814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51815       };
51816     } catch (std::exception& e) {
51817       {
51818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51819       };
51820     } catch (Dali::DaliException e) {
51821       {
51822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51823       };
51824     } catch (...) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51827       };
51828     }
51829   }
51830
51831   jresult = (void *)result;
51832   return jresult;
51833 }
51834
51835
51836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51837   void * jresult ;
51838   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51839   Dali::Vector< float >::Iterator result;
51840
51841   arg1 = (Dali::Vector< float > *)jarg1;
51842   {
51843     try {
51844       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51845     } catch (std::out_of_range& e) {
51846       {
51847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51848       };
51849     } catch (std::exception& e) {
51850       {
51851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51852       };
51853     } catch (Dali::DaliException e) {
51854       {
51855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51856       };
51857     } catch (...) {
51858       {
51859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51860       };
51861     }
51862   }
51863
51864   jresult = (void *)result;
51865   return jresult;
51866 }
51867
51868
51869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51870   void * jresult ;
51871   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51872   Dali::Vector< float >::SizeType arg2 ;
51873   Dali::Vector< float >::ItemType *result = 0 ;
51874
51875   arg1 = (Dali::Vector< float > *)jarg1;
51876   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51877   {
51878     try {
51879       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51880     } catch (std::out_of_range& e) {
51881       {
51882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51883       };
51884     } catch (std::exception& e) {
51885       {
51886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51887       };
51888     } catch (Dali::DaliException e) {
51889       {
51890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51891       };
51892     } catch (...) {
51893       {
51894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51895       };
51896     }
51897   }
51898
51899   jresult = (void *)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51905   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51906   Dali::Vector< float >::ItemType *arg2 = 0 ;
51907   Dali::Vector< float >::ItemType temp2 ;
51908
51909   arg1 = (Dali::Vector< float > *)jarg1;
51910   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51911   arg2 = &temp2;
51912   {
51913     try {
51914       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51915     } catch (std::out_of_range& e) {
51916       {
51917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51918       };
51919     } catch (std::exception& e) {
51920       {
51921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51922       };
51923     } catch (Dali::DaliException e) {
51924       {
51925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51926       };
51927     } catch (...) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51930       };
51931     }
51932   }
51933
51934 }
51935
51936
51937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51938   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51939   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51940   Dali::Vector< float >::ItemType *arg3 = 0 ;
51941   Dali::Vector< float >::ItemType temp3 ;
51942
51943   arg1 = (Dali::Vector< float > *)jarg1;
51944   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51945   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51946   arg3 = &temp3;
51947   {
51948     try {
51949       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51950     } catch (std::out_of_range& e) {
51951       {
51952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51953       };
51954     } catch (std::exception& e) {
51955       {
51956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51957       };
51958     } catch (Dali::DaliException e) {
51959       {
51960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51961       };
51962     } catch (...) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51965       };
51966     }
51967   }
51968
51969 }
51970
51971
51972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51973   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51974   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51975   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51976   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51977
51978   arg1 = (Dali::Vector< float > *)jarg1;
51979   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51980   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51981   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51982   {
51983     try {
51984       (arg1)->Insert(arg2,arg3,arg4);
51985     } catch (std::out_of_range& e) {
51986       {
51987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51988       };
51989     } catch (std::exception& e) {
51990       {
51991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51992       };
51993     } catch (Dali::DaliException e) {
51994       {
51995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51996       };
51997     } catch (...) {
51998       {
51999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52000       };
52001     }
52002   }
52003
52004 }
52005
52006
52007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52008   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52009   Dali::Vector< float >::SizeType arg2 ;
52010
52011   arg1 = (Dali::Vector< float > *)jarg1;
52012   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52013   {
52014     try {
52015       (arg1)->Reserve(arg2);
52016     } catch (std::out_of_range& e) {
52017       {
52018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52019       };
52020     } catch (std::exception& e) {
52021       {
52022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52023       };
52024     } catch (Dali::DaliException e) {
52025       {
52026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52027       };
52028     } catch (...) {
52029       {
52030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52031       };
52032     }
52033   }
52034
52035 }
52036
52037 //// ========================= end of part 2 =============================
52038
52039 //// ========================== start part 3 ===============================
52040
52041
52042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52043   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52044   Dali::Vector< float >::SizeType arg2 ;
52045
52046   arg1 = (Dali::Vector< float > *)jarg1;
52047   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52048   {
52049     try {
52050       (arg1)->Resize(arg2);
52051     } catch (std::out_of_range& e) {
52052       {
52053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52054       };
52055     } catch (std::exception& e) {
52056       {
52057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52058       };
52059     } catch (Dali::DaliException e) {
52060       {
52061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52062       };
52063     } catch (...) {
52064       {
52065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52066       };
52067     }
52068   }
52069
52070 }
52071
52072
52073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52074   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52075   Dali::Vector< float >::SizeType arg2 ;
52076   Dali::Vector< float >::ItemType *arg3 = 0 ;
52077   Dali::Vector< float >::ItemType temp3 ;
52078
52079   arg1 = (Dali::Vector< float > *)jarg1;
52080   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52081   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52082   arg3 = &temp3;
52083   {
52084     try {
52085       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52086     } catch (std::out_of_range& e) {
52087       {
52088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52089       };
52090     } catch (std::exception& e) {
52091       {
52092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52093       };
52094     } catch (Dali::DaliException e) {
52095       {
52096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52097       };
52098     } catch (...) {
52099       {
52100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52101       };
52102     }
52103   }
52104
52105 }
52106
52107
52108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52109   void * jresult ;
52110   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52111   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52112   Dali::Vector< float >::Iterator result;
52113
52114   arg1 = (Dali::Vector< float > *)jarg1;
52115   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52116   {
52117     try {
52118       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52119     } catch (std::out_of_range& e) {
52120       {
52121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52122       };
52123     } catch (std::exception& e) {
52124       {
52125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52126       };
52127     } catch (Dali::DaliException e) {
52128       {
52129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52130       };
52131     } catch (...) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52134       };
52135     }
52136   }
52137
52138   jresult = (void *)result;
52139   return jresult;
52140 }
52141
52142
52143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52144   void * jresult ;
52145   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52146   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52147   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52148   Dali::Vector< float >::Iterator result;
52149
52150   arg1 = (Dali::Vector< float > *)jarg1;
52151   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52152   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52153   {
52154     try {
52155       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52156     } catch (std::out_of_range& e) {
52157       {
52158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52159       };
52160     } catch (std::exception& e) {
52161       {
52162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52163       };
52164     } catch (Dali::DaliException e) {
52165       {
52166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52167       };
52168     } catch (...) {
52169       {
52170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52171       };
52172     }
52173   }
52174
52175   jresult = (void *)result;
52176   return jresult;
52177 }
52178
52179
52180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52181   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52182   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52183
52184   arg1 = (Dali::Vector< float > *)jarg1;
52185   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52186   {
52187     try {
52188       (arg1)->Remove(arg2);
52189     } catch (std::out_of_range& e) {
52190       {
52191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52192       };
52193     } catch (std::exception& e) {
52194       {
52195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52196       };
52197     } catch (Dali::DaliException e) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52200       };
52201     } catch (...) {
52202       {
52203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52204       };
52205     }
52206   }
52207
52208 }
52209
52210
52211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52212   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52213   Dali::Vector< float > *arg2 = 0 ;
52214
52215   arg1 = (Dali::Vector< float > *)jarg1;
52216   arg2 = (Dali::Vector< float > *)jarg2;
52217   if (!arg2) {
52218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52219     return ;
52220   }
52221   {
52222     try {
52223       (arg1)->Swap(*arg2);
52224     } catch (std::out_of_range& e) {
52225       {
52226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52227       };
52228     } catch (std::exception& e) {
52229       {
52230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52231       };
52232     } catch (Dali::DaliException e) {
52233       {
52234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52235       };
52236     } catch (...) {
52237       {
52238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52239       };
52240     }
52241   }
52242
52243 }
52244
52245
52246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52247   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52248
52249   arg1 = (Dali::Vector< float > *)jarg1;
52250   {
52251     try {
52252       (arg1)->Clear();
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (Dali::DaliException e) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52264       };
52265     } catch (...) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52268       };
52269     }
52270   }
52271
52272 }
52273
52274
52275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52276   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52277
52278   arg1 = (Dali::Vector< float > *)jarg1;
52279   {
52280     try {
52281       (arg1)->Release();
52282     } catch (std::out_of_range& e) {
52283       {
52284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52285       };
52286     } catch (std::exception& e) {
52287       {
52288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52289       };
52290     } catch (Dali::DaliException e) {
52291       {
52292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52293       };
52294     } catch (...) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52297       };
52298     }
52299   }
52300
52301 }
52302
52303
52304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52305   int jresult ;
52306   int result;
52307
52308   result = (int)Dali::Vector< unsigned char >::BaseType;
52309   jresult = (int)result;
52310   return jresult;
52311 }
52312
52313
52314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52315   void * jresult ;
52316   Dali::Vector< unsigned char > *result = 0 ;
52317
52318   {
52319     try {
52320       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52321     } catch (std::out_of_range& e) {
52322       {
52323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52324       };
52325     } catch (std::exception& e) {
52326       {
52327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52328       };
52329     } catch (Dali::DaliException e) {
52330       {
52331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52332       };
52333     } catch (...) {
52334       {
52335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52336       };
52337     }
52338   }
52339
52340   jresult = (void *)result;
52341   return jresult;
52342 }
52343
52344
52345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52346   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52347
52348   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52349   {
52350     try {
52351       delete arg1;
52352     } catch (std::out_of_range& e) {
52353       {
52354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52355       };
52356     } catch (std::exception& e) {
52357       {
52358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52359       };
52360     } catch (Dali::DaliException e) {
52361       {
52362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52363       };
52364     } catch (...) {
52365       {
52366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52367       };
52368     }
52369   }
52370
52371 }
52372
52373
52374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52375   void * jresult ;
52376   Dali::Vector< unsigned char > *arg1 = 0 ;
52377   Dali::Vector< unsigned char > *result = 0 ;
52378
52379   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52380   if (!arg1) {
52381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52382     return 0;
52383   }
52384   {
52385     try {
52386       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52387     } catch (std::out_of_range& e) {
52388       {
52389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52390       };
52391     } catch (std::exception& e) {
52392       {
52393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52394       };
52395     } catch (Dali::DaliException e) {
52396       {
52397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52398       };
52399     } catch (...) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52402       };
52403     }
52404   }
52405
52406   jresult = (void *)result;
52407   return jresult;
52408 }
52409
52410
52411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52412   void * jresult ;
52413   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52414   Dali::Vector< unsigned char > *arg2 = 0 ;
52415   Dali::Vector< unsigned char > *result = 0 ;
52416
52417   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52418   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52419   if (!arg2) {
52420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52421     return 0;
52422   }
52423   {
52424     try {
52425       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52426     } catch (std::out_of_range& e) {
52427       {
52428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52429       };
52430     } catch (std::exception& e) {
52431       {
52432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52433       };
52434     } catch (Dali::DaliException e) {
52435       {
52436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52437       };
52438     } catch (...) {
52439       {
52440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52441       };
52442     }
52443   }
52444
52445   jresult = (void *)result;
52446   return jresult;
52447 }
52448
52449
52450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52451   void * jresult ;
52452   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52453   Dali::Vector< unsigned char >::Iterator result;
52454
52455   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52456   {
52457     try {
52458       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52459     } catch (std::out_of_range& e) {
52460       {
52461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52462       };
52463     } catch (std::exception& e) {
52464       {
52465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52466       };
52467     } catch (Dali::DaliException e) {
52468       {
52469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52470       };
52471     } catch (...) {
52472       {
52473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52474       };
52475     }
52476   }
52477
52478   jresult = (void *)result;
52479   return jresult;
52480 }
52481
52482
52483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52484   void * jresult ;
52485   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52486   Dali::Vector< unsigned char >::Iterator result;
52487
52488   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52489   {
52490     try {
52491       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52492     } catch (std::out_of_range& e) {
52493       {
52494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52495       };
52496     } catch (std::exception& e) {
52497       {
52498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52499       };
52500     } catch (Dali::DaliException e) {
52501       {
52502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52503       };
52504     } catch (...) {
52505       {
52506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52507       };
52508     }
52509   }
52510
52511   jresult = (void *)result;
52512   return jresult;
52513 }
52514
52515
52516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52517   void * jresult ;
52518   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52519   Dali::Vector< unsigned char >::SizeType arg2 ;
52520   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52521
52522   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52523   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52524   {
52525     try {
52526       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52527     } catch (std::out_of_range& e) {
52528       {
52529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52530       };
52531     } catch (std::exception& e) {
52532       {
52533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52534       };
52535     } catch (Dali::DaliException e) {
52536       {
52537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52538       };
52539     } catch (...) {
52540       {
52541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52542       };
52543     }
52544   }
52545
52546   jresult = (void *)result;
52547   return jresult;
52548 }
52549
52550
52551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52552   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52553   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52554   Dali::Vector< unsigned char >::ItemType temp2 ;
52555
52556   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52557   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52558   arg2 = &temp2;
52559   {
52560     try {
52561       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52562     } catch (std::out_of_range& e) {
52563       {
52564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52565       };
52566     } catch (std::exception& e) {
52567       {
52568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52569       };
52570     } catch (Dali::DaliException e) {
52571       {
52572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52573       };
52574     } catch (...) {
52575       {
52576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52577       };
52578     }
52579   }
52580
52581 }
52582
52583
52584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52585   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52586   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52587   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52588   Dali::Vector< unsigned char >::ItemType temp3 ;
52589
52590   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52591   arg2 = jarg2;
52592   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52593   arg3 = &temp3;
52594   {
52595     try {
52596       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52597     } catch (std::out_of_range& e) {
52598       {
52599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52600       };
52601     } catch (std::exception& e) {
52602       {
52603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (Dali::DaliException e) {
52606       {
52607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52608       };
52609     } catch (...) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52612       };
52613     }
52614   }
52615
52616
52617
52618 }
52619
52620
52621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52622   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52623   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52624   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52625   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52626
52627   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52628   arg2 = jarg2;
52629   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52630   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52631   {
52632     try {
52633       (arg1)->Insert(arg2,arg3,arg4);
52634     } catch (std::out_of_range& e) {
52635       {
52636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52637       };
52638     } catch (std::exception& e) {
52639       {
52640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52641       };
52642     } catch (Dali::DaliException e) {
52643       {
52644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52645       };
52646     } catch (...) {
52647       {
52648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52649       };
52650     }
52651   }
52652
52653
52654
52655 }
52656
52657
52658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52659   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52660   Dali::Vector< unsigned char >::SizeType arg2 ;
52661
52662   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52663   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52664   {
52665     try {
52666       (arg1)->Reserve(arg2);
52667     } catch (std::out_of_range& e) {
52668       {
52669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52670       };
52671     } catch (std::exception& e) {
52672       {
52673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (Dali::DaliException e) {
52676       {
52677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52678       };
52679     } catch (...) {
52680       {
52681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52682       };
52683     }
52684   }
52685
52686 }
52687
52688
52689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52690   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52691   Dali::Vector< unsigned char >::SizeType arg2 ;
52692
52693   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52694   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52695   {
52696     try {
52697       (arg1)->Resize(arg2);
52698     } catch (std::out_of_range& e) {
52699       {
52700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52701       };
52702     } catch (std::exception& e) {
52703       {
52704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52705       };
52706     } catch (Dali::DaliException e) {
52707       {
52708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52709       };
52710     } catch (...) {
52711       {
52712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52713       };
52714     }
52715   }
52716
52717 }
52718
52719
52720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52721   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52722   Dali::Vector< unsigned char >::SizeType arg2 ;
52723   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52724   Dali::Vector< unsigned char >::ItemType temp3 ;
52725
52726   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52727   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52728   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52729   arg3 = &temp3;
52730   {
52731     try {
52732       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52733     } catch (std::out_of_range& e) {
52734       {
52735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52736       };
52737     } catch (std::exception& e) {
52738       {
52739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52740       };
52741     } catch (Dali::DaliException e) {
52742       {
52743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52744       };
52745     } catch (...) {
52746       {
52747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52748       };
52749     }
52750   }
52751
52752 }
52753
52754
52755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52756   void * jresult ;
52757   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52758   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52759   Dali::Vector< unsigned char >::Iterator result;
52760
52761   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52762   arg2 = jarg2;
52763   {
52764     try {
52765       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52766     } catch (std::out_of_range& e) {
52767       {
52768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52769       };
52770     } catch (std::exception& e) {
52771       {
52772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (Dali::DaliException e) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52777       };
52778     } catch (...) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52781       };
52782     }
52783   }
52784
52785   jresult = (void *)result;
52786
52787
52788   return jresult;
52789 }
52790
52791
52792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52793   void * jresult ;
52794   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52795   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52796   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52797   Dali::Vector< unsigned char >::Iterator result;
52798
52799   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52800   arg2 = jarg2;
52801   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52802   {
52803     try {
52804       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52805     } catch (std::out_of_range& e) {
52806       {
52807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52808       };
52809     } catch (std::exception& e) {
52810       {
52811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52812       };
52813     } catch (Dali::DaliException e) {
52814       {
52815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52816       };
52817     } catch (...) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52820       };
52821     }
52822   }
52823
52824   jresult = (void *)result;
52825
52826
52827   return jresult;
52828 }
52829
52830
52831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52832   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52833   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52834
52835   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52836   arg2 = jarg2;
52837   {
52838     try {
52839       (arg1)->Remove(arg2);
52840     } catch (std::out_of_range& e) {
52841       {
52842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52843       };
52844     } catch (std::exception& e) {
52845       {
52846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52847       };
52848     } catch (Dali::DaliException e) {
52849       {
52850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52851       };
52852     } catch (...) {
52853       {
52854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52855       };
52856     }
52857   }
52858
52859
52860
52861 }
52862
52863
52864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52865   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52866   Dali::Vector< unsigned char > *arg2 = 0 ;
52867
52868   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52869   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52870   if (!arg2) {
52871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52872     return ;
52873   }
52874   {
52875     try {
52876       (arg1)->Swap(*arg2);
52877     } catch (std::out_of_range& e) {
52878       {
52879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52880       };
52881     } catch (std::exception& e) {
52882       {
52883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52884       };
52885     } catch (Dali::DaliException e) {
52886       {
52887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52888       };
52889     } catch (...) {
52890       {
52891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52892       };
52893     }
52894   }
52895
52896 }
52897
52898
52899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52900   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52901
52902   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52903   {
52904     try {
52905       (arg1)->Clear();
52906     } catch (std::out_of_range& e) {
52907       {
52908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52909       };
52910     } catch (std::exception& e) {
52911       {
52912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52913       };
52914     } catch (Dali::DaliException e) {
52915       {
52916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52917       };
52918     } catch (...) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52921       };
52922     }
52923   }
52924
52925 }
52926
52927
52928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52929   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52930
52931   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52932   {
52933     try {
52934       (arg1)->Release();
52935     } catch (std::out_of_range& e) {
52936       {
52937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52938       };
52939     } catch (std::exception& e) {
52940       {
52941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52942       };
52943     } catch (Dali::DaliException e) {
52944       {
52945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52946       };
52947     } catch (...) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52950       };
52951     }
52952   }
52953
52954 }
52955
52956
52957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52958   int jresult ;
52959   int result;
52960
52961   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52962   jresult = (int)result;
52963   return jresult;
52964 }
52965
52966
52967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52968   void * jresult ;
52969   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52970
52971   {
52972     try {
52973       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52974     } catch (std::out_of_range& e) {
52975       {
52976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (std::exception& e) {
52979       {
52980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52981       };
52982     } catch (Dali::DaliException e) {
52983       {
52984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52985       };
52986     } catch (...) {
52987       {
52988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52989       };
52990     }
52991   }
52992
52993   jresult = (void *)result;
52994   return jresult;
52995 }
52996
52997
52998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52999   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53000
53001   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53002   {
53003     try {
53004       delete arg1;
53005     } catch (std::out_of_range& e) {
53006       {
53007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53008       };
53009     } catch (std::exception& e) {
53010       {
53011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53012       };
53013     } catch (Dali::DaliException e) {
53014       {
53015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53016       };
53017     } catch (...) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53020       };
53021     }
53022   }
53023
53024 }
53025
53026
53027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53028   void * jresult ;
53029   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53030   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53031
53032   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53033   if (!arg1) {
53034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53035     return 0;
53036   }
53037   {
53038     try {
53039       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53040     } catch (std::out_of_range& e) {
53041       {
53042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53043       };
53044     } catch (std::exception& e) {
53045       {
53046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53047       };
53048     } catch (Dali::DaliException e) {
53049       {
53050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53051       };
53052     } catch (...) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53055       };
53056     }
53057   }
53058
53059   jresult = (void *)result;
53060   return jresult;
53061 }
53062
53063
53064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53065   void * jresult ;
53066   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53067   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53068   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53069
53070   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53071   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53072   if (!arg2) {
53073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53074     return 0;
53075   }
53076   {
53077     try {
53078       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53079     } catch (std::out_of_range& e) {
53080       {
53081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53082       };
53083     } catch (std::exception& e) {
53084       {
53085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53086       };
53087     } catch (Dali::DaliException e) {
53088       {
53089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53090       };
53091     } catch (...) {
53092       {
53093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53094       };
53095     }
53096   }
53097
53098   jresult = (void *)result;
53099   return jresult;
53100 }
53101
53102
53103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53104   void * jresult ;
53105   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53106   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53107
53108   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53109   {
53110     try {
53111       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53112     } catch (std::out_of_range& e) {
53113       {
53114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53115       };
53116     } catch (std::exception& e) {
53117       {
53118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53119       };
53120     } catch (Dali::DaliException e) {
53121       {
53122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53123       };
53124     } catch (...) {
53125       {
53126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53127       };
53128     }
53129   }
53130
53131   jresult = (void *)result;
53132   return jresult;
53133 }
53134
53135
53136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53137   void * jresult ;
53138   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53139   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53140
53141   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53142   {
53143     try {
53144       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53145     } catch (std::out_of_range& e) {
53146       {
53147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53148       };
53149     } catch (std::exception& e) {
53150       {
53151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53152       };
53153     } catch (Dali::DaliException e) {
53154       {
53155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53156       };
53157     } catch (...) {
53158       {
53159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53160       };
53161     }
53162   }
53163
53164   jresult = (void *)result;
53165   return jresult;
53166 }
53167
53168
53169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53170   void * jresult ;
53171   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53172   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53173   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53174
53175   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53176   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53177   {
53178     try {
53179       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53180     } catch (std::out_of_range& e) {
53181       {
53182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53183       };
53184     } catch (std::exception& e) {
53185       {
53186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53187       };
53188     } catch (Dali::DaliException e) {
53189       {
53190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53191       };
53192     } catch (...) {
53193       {
53194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53195       };
53196     }
53197   }
53198
53199   jresult = (void *)result;
53200   return jresult;
53201 }
53202
53203
53204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53205   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53206   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53207
53208   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53209   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53210   if (!arg2) {
53211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53212     return ;
53213   }
53214   {
53215     try {
53216       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53217     } catch (std::out_of_range& e) {
53218       {
53219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53220       };
53221     } catch (std::exception& e) {
53222       {
53223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53224       };
53225     } catch (Dali::DaliException e) {
53226       {
53227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53228       };
53229     } catch (...) {
53230       {
53231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53232       };
53233     }
53234   }
53235
53236 }
53237
53238
53239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53240   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53241   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53242   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53243
53244   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53245   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53246   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53247   if (!arg3) {
53248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53249     return ;
53250   }
53251   {
53252     try {
53253       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53254     } catch (std::out_of_range& e) {
53255       {
53256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53257       };
53258     } catch (std::exception& e) {
53259       {
53260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53261       };
53262     } catch (Dali::DaliException e) {
53263       {
53264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53265       };
53266     } catch (...) {
53267       {
53268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53269       };
53270     }
53271   }
53272
53273 }
53274
53275
53276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53277   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53278   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53279   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53280   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53281
53282   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53283   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53284   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53285   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53286   {
53287     try {
53288       (arg1)->Insert(arg2,arg3,arg4);
53289     } catch (std::out_of_range& e) {
53290       {
53291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53292       };
53293     } catch (std::exception& e) {
53294       {
53295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53296       };
53297     } catch (Dali::DaliException e) {
53298       {
53299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53300       };
53301     } catch (...) {
53302       {
53303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53304       };
53305     }
53306   }
53307
53308 }
53309
53310
53311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53312   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53313   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53314
53315   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53316   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53317   {
53318     try {
53319       (arg1)->Reserve(arg2);
53320     } catch (std::out_of_range& e) {
53321       {
53322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53323       };
53324     } catch (std::exception& e) {
53325       {
53326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53327       };
53328     } catch (Dali::DaliException e) {
53329       {
53330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53331       };
53332     } catch (...) {
53333       {
53334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53335       };
53336     }
53337   }
53338
53339 }
53340
53341
53342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53343   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53344   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53345
53346   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53347   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53348   {
53349     try {
53350       (arg1)->Resize(arg2);
53351     } catch (std::out_of_range& e) {
53352       {
53353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53354       };
53355     } catch (std::exception& e) {
53356       {
53357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53358       };
53359     } catch (Dali::DaliException e) {
53360       {
53361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53362       };
53363     } catch (...) {
53364       {
53365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53366       };
53367     }
53368   }
53369
53370 }
53371
53372
53373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53374   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53375   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53376   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53377
53378   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53379   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53380   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53381   if (!arg3) {
53382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53383     return ;
53384   }
53385   {
53386     try {
53387       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53388     } catch (std::out_of_range& e) {
53389       {
53390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (std::exception& e) {
53393       {
53394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53395       };
53396     } catch (Dali::DaliException e) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53399       };
53400     } catch (...) {
53401       {
53402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53403       };
53404     }
53405   }
53406
53407 }
53408
53409
53410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53411   void * jresult ;
53412   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53413   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53414   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53415
53416   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53417   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53418   {
53419     try {
53420       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53421     } catch (std::out_of_range& e) {
53422       {
53423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53424       };
53425     } catch (std::exception& e) {
53426       {
53427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53428       };
53429     } catch (Dali::DaliException e) {
53430       {
53431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53432       };
53433     } catch (...) {
53434       {
53435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53436       };
53437     }
53438   }
53439
53440   jresult = (void *)result;
53441   return jresult;
53442 }
53443
53444
53445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53446   void * jresult ;
53447   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53448   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53449   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53450   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53451
53452   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53453   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53454   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53455   {
53456     try {
53457       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53458     } catch (std::out_of_range& e) {
53459       {
53460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53461       };
53462     } catch (std::exception& e) {
53463       {
53464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53465       };
53466     } catch (Dali::DaliException e) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53469       };
53470     } catch (...) {
53471       {
53472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53473       };
53474     }
53475   }
53476
53477   jresult = (void *)result;
53478   return jresult;
53479 }
53480
53481
53482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53483   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53484   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53485
53486   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53487   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53488   {
53489     try {
53490       (arg1)->Remove(arg2);
53491     } catch (std::out_of_range& e) {
53492       {
53493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53494       };
53495     } catch (std::exception& e) {
53496       {
53497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53498       };
53499     } catch (Dali::DaliException e) {
53500       {
53501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53502       };
53503     } catch (...) {
53504       {
53505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53506       };
53507     }
53508   }
53509
53510 }
53511
53512
53513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53514   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53515   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53516
53517   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53518   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53519   if (!arg2) {
53520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53521     return ;
53522   }
53523   {
53524     try {
53525       (arg1)->Swap(*arg2);
53526     } catch (std::out_of_range& e) {
53527       {
53528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53529       };
53530     } catch (std::exception& e) {
53531       {
53532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53533       };
53534     } catch (Dali::DaliException e) {
53535       {
53536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53537       };
53538     } catch (...) {
53539       {
53540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53541       };
53542     }
53543   }
53544
53545 }
53546
53547
53548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53549   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53550
53551   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53552   {
53553     try {
53554       (arg1)->Clear();
53555     } catch (std::out_of_range& e) {
53556       {
53557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53558       };
53559     } catch (std::exception& e) {
53560       {
53561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53562       };
53563     } catch (Dali::DaliException e) {
53564       {
53565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53566       };
53567     } catch (...) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53570       };
53571     }
53572   }
53573
53574 }
53575
53576
53577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53578   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53579
53580   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53581   {
53582     try {
53583       (arg1)->Release();
53584     } catch (std::out_of_range& e) {
53585       {
53586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53587       };
53588     } catch (std::exception& e) {
53589       {
53590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53591       };
53592     } catch (Dali::DaliException e) {
53593       {
53594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53595       };
53596     } catch (...) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53599       };
53600     }
53601   }
53602
53603 }
53604
53605
53606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53607   void * jresult ;
53608   Dali::Signal< void () > *result = 0 ;
53609
53610   {
53611     try {
53612       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53613     } catch (std::out_of_range& e) {
53614       {
53615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53616       };
53617     } catch (std::exception& e) {
53618       {
53619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53620       };
53621     } catch (Dali::DaliException e) {
53622       {
53623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53624       };
53625     } catch (...) {
53626       {
53627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53628       };
53629     }
53630   }
53631
53632   jresult = (void *)result;
53633   return jresult;
53634 }
53635
53636
53637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53638   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53639
53640   arg1 = (Dali::Signal< void () > *)jarg1;
53641   {
53642     try {
53643       delete arg1;
53644     } catch (std::out_of_range& e) {
53645       {
53646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53647       };
53648     } catch (std::exception& e) {
53649       {
53650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53651       };
53652     } catch (Dali::DaliException e) {
53653       {
53654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53655       };
53656     } catch (...) {
53657       {
53658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53659       };
53660     }
53661   }
53662
53663 }
53664
53665
53666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53667   unsigned int jresult ;
53668   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53669   bool result;
53670
53671   arg1 = (Dali::Signal< void () > *)jarg1;
53672   {
53673     try {
53674       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53675     } catch (std::out_of_range& e) {
53676       {
53677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53678       };
53679     } catch (std::exception& e) {
53680       {
53681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53682       };
53683     } catch (Dali::DaliException e) {
53684       {
53685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53686       };
53687     } catch (...) {
53688       {
53689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53690       };
53691     }
53692   }
53693
53694   jresult = result;
53695   return jresult;
53696 }
53697
53698
53699 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53700   unsigned long jresult ;
53701   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53702   std::size_t result;
53703
53704   arg1 = (Dali::Signal< void () > *)jarg1;
53705   {
53706     try {
53707       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53708     } catch (std::out_of_range& e) {
53709       {
53710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53711       };
53712     } catch (std::exception& e) {
53713       {
53714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (Dali::DaliException e) {
53717       {
53718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53719       };
53720     } catch (...) {
53721       {
53722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53723       };
53724     }
53725   }
53726
53727   jresult = (unsigned long)result;
53728   return jresult;
53729 }
53730
53731
53732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53733   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53734   void (*arg2)() = (void (*)()) 0 ;
53735
53736   arg1 = (Dali::Signal< void () > *)jarg1;
53737   arg2 = (void (*)())jarg2;
53738   {
53739     try {
53740       (arg1)->Connect(arg2);
53741     } catch (std::out_of_range& e) {
53742       {
53743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53744       };
53745     } catch (std::exception& e) {
53746       {
53747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53748       };
53749     } catch (Dali::DaliException e) {
53750       {
53751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53752       };
53753     } catch (...) {
53754       {
53755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53756       };
53757     }
53758   }
53759
53760 }
53761
53762
53763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53764   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53765   void (*arg2)() = (void (*)()) 0 ;
53766
53767   arg1 = (Dali::Signal< void () > *)jarg1;
53768   arg2 = (void (*)())jarg2;
53769   {
53770     try {
53771       (arg1)->Disconnect(arg2);
53772     } catch (std::out_of_range& e) {
53773       {
53774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53775       };
53776     } catch (std::exception& e) {
53777       {
53778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53779       };
53780     } catch (Dali::DaliException e) {
53781       {
53782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53783       };
53784     } catch (...) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53787       };
53788     }
53789   }
53790
53791 }
53792
53793
53794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53795   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53796   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53797   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53798
53799   arg1 = (Dali::Signal< void () > *)jarg1;
53800   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53801   arg3 = (Dali::FunctorDelegate *)jarg3;
53802   {
53803     try {
53804       (arg1)->Connect(arg2,arg3);
53805     } catch (std::out_of_range& e) {
53806       {
53807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53808       };
53809     } catch (std::exception& e) {
53810       {
53811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53812       };
53813     } catch (Dali::DaliException e) {
53814       {
53815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53816       };
53817     } catch (...) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53820       };
53821     }
53822   }
53823
53824 }
53825
53826
53827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53828   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53829
53830   arg1 = (Dali::Signal< void () > *)jarg1;
53831   {
53832     try {
53833       (arg1)->Emit();
53834     } catch (std::out_of_range& e) {
53835       {
53836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53837       };
53838     } catch (std::exception& e) {
53839       {
53840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53841       };
53842     } catch (Dali::DaliException e) {
53843       {
53844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53845       };
53846     } catch (...) {
53847       {
53848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53849       };
53850     }
53851   }
53852
53853 }
53854
53855
53856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53857   unsigned int jresult ;
53858   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53859   bool result;
53860
53861   arg1 = (Dali::Signal< void (float) > *)jarg1;
53862   {
53863     try {
53864       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53865     } catch (std::out_of_range& e) {
53866       {
53867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53868       };
53869     } catch (std::exception& e) {
53870       {
53871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53872       };
53873     } catch (Dali::DaliException e) {
53874       {
53875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53876       };
53877     } catch (...) {
53878       {
53879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53880       };
53881     }
53882   }
53883
53884   jresult = result;
53885   return jresult;
53886 }
53887
53888
53889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53890   unsigned long jresult ;
53891   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53892   std::size_t result;
53893
53894   arg1 = (Dali::Signal< void (float) > *)jarg1;
53895   {
53896     try {
53897       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53898     } catch (std::out_of_range& e) {
53899       {
53900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53901       };
53902     } catch (std::exception& e) {
53903       {
53904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53905       };
53906     } catch (Dali::DaliException e) {
53907       {
53908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53909       };
53910     } catch (...) {
53911       {
53912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53913       };
53914     }
53915   }
53916
53917   jresult = (unsigned long)result;
53918   return jresult;
53919 }
53920
53921
53922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53923   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53924   void (*arg2)(float) = (void (*)(float)) 0 ;
53925
53926   arg1 = (Dali::Signal< void (float) > *)jarg1;
53927   arg2 = (void (*)(float))jarg2;
53928   {
53929     try {
53930       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53931     } catch (std::out_of_range& e) {
53932       {
53933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53934       };
53935     } catch (std::exception& e) {
53936       {
53937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53938       };
53939     } catch (Dali::DaliException e) {
53940       {
53941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53942       };
53943     } catch (...) {
53944       {
53945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53946       };
53947     }
53948   }
53949
53950 }
53951
53952
53953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53954   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53955   void (*arg2)(float) = (void (*)(float)) 0 ;
53956
53957   arg1 = (Dali::Signal< void (float) > *)jarg1;
53958   arg2 = (void (*)(float))jarg2;
53959   {
53960     try {
53961       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53962     } catch (std::out_of_range& e) {
53963       {
53964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53965       };
53966     } catch (std::exception& e) {
53967       {
53968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53969       };
53970     } catch (Dali::DaliException e) {
53971       {
53972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53973       };
53974     } catch (...) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53977       };
53978     }
53979   }
53980
53981 }
53982
53983
53984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53985   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53986   float arg2 ;
53987
53988   arg1 = (Dali::Signal< void (float) > *)jarg1;
53989   arg2 = (float)jarg2;
53990   {
53991     try {
53992       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53993     } catch (std::out_of_range& e) {
53994       {
53995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53996       };
53997     } catch (std::exception& e) {
53998       {
53999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54000       };
54001     } catch (Dali::DaliException e) {
54002       {
54003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54004       };
54005     } catch (...) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54008       };
54009     }
54010   }
54011
54012 }
54013
54014
54015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54016   void * jresult ;
54017   Dali::Signal< void (float) > *result = 0 ;
54018
54019   {
54020     try {
54021       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54022     } catch (std::out_of_range& e) {
54023       {
54024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54025       };
54026     } catch (std::exception& e) {
54027       {
54028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54029       };
54030     } catch (Dali::DaliException e) {
54031       {
54032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54033       };
54034     } catch (...) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54037       };
54038     }
54039   }
54040
54041   jresult = (void *)result;
54042   return jresult;
54043 }
54044
54045
54046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54047   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54048
54049   arg1 = (Dali::Signal< void (float) > *)jarg1;
54050   {
54051     try {
54052       delete arg1;
54053     } catch (std::out_of_range& e) {
54054       {
54055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54056       };
54057     } catch (std::exception& e) {
54058       {
54059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54060       };
54061     } catch (Dali::DaliException e) {
54062       {
54063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54064       };
54065     } catch (...) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54068       };
54069     }
54070   }
54071
54072 }
54073
54074
54075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54076   unsigned int jresult ;
54077   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54078   bool result;
54079
54080   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54081   {
54082     try {
54083       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54084     } catch (std::out_of_range& e) {
54085       {
54086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54087       };
54088     } catch (std::exception& e) {
54089       {
54090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54091       };
54092     } catch (Dali::DaliException e) {
54093       {
54094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54095       };
54096     } catch (...) {
54097       {
54098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54099       };
54100     }
54101   }
54102
54103   jresult = result;
54104   return jresult;
54105 }
54106
54107
54108 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54109   unsigned long jresult ;
54110   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54111   std::size_t result;
54112
54113   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54114   {
54115     try {
54116       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54117     } catch (std::out_of_range& e) {
54118       {
54119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54120       };
54121     } catch (std::exception& e) {
54122       {
54123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54124       };
54125     } catch (Dali::DaliException e) {
54126       {
54127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54128       };
54129     } catch (...) {
54130       {
54131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54132       };
54133     }
54134   }
54135
54136   jresult = (unsigned long)result;
54137   return jresult;
54138 }
54139
54140
54141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54142   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54143   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54144
54145   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54146   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54147   {
54148     try {
54149       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54150     } catch (std::out_of_range& e) {
54151       {
54152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54153       };
54154     } catch (std::exception& e) {
54155       {
54156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54157       };
54158     } catch (Dali::DaliException e) {
54159       {
54160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54161       };
54162     } catch (...) {
54163       {
54164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54165       };
54166     }
54167   }
54168
54169 }
54170
54171
54172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54173   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54174   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54175
54176   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54177   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54178   {
54179     try {
54180       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54181     } catch (std::out_of_range& e) {
54182       {
54183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54184       };
54185     } catch (std::exception& e) {
54186       {
54187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54188       };
54189     } catch (Dali::DaliException e) {
54190       {
54191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54192       };
54193     } catch (...) {
54194       {
54195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54196       };
54197     }
54198   }
54199
54200 }
54201
54202
54203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54204   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54205   Dali::BaseHandle arg2 ;
54206   Dali::BaseHandle *argp2 ;
54207
54208   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54209   argp2 = (Dali::BaseHandle *)jarg2;
54210   if (!argp2) {
54211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54212     return ;
54213   }
54214   arg2 = *argp2;
54215   {
54216     try {
54217       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54218     } catch (std::out_of_range& e) {
54219       {
54220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54221       };
54222     } catch (std::exception& e) {
54223       {
54224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54225       };
54226     } catch (Dali::DaliException e) {
54227       {
54228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54229       };
54230     } catch (...) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54233       };
54234     }
54235   }
54236
54237 }
54238
54239
54240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54241   void * jresult ;
54242   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54243
54244   {
54245     try {
54246       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54247     } catch (std::out_of_range& e) {
54248       {
54249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54250       };
54251     } catch (std::exception& e) {
54252       {
54253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (Dali::DaliException e) {
54256       {
54257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54258       };
54259     } catch (...) {
54260       {
54261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54262       };
54263     }
54264   }
54265
54266   jresult = (void *)result;
54267   return jresult;
54268 }
54269
54270
54271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54272   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54273
54274   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54275   {
54276     try {
54277       delete arg1;
54278     } catch (std::out_of_range& e) {
54279       {
54280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54281       };
54282     } catch (std::exception& e) {
54283       {
54284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54285       };
54286     } catch (Dali::DaliException e) {
54287       {
54288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54289       };
54290     } catch (...) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54293       };
54294     }
54295   }
54296
54297 }
54298
54299
54300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54301   unsigned int jresult ;
54302   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54303   bool result;
54304
54305   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54306   {
54307     try {
54308       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54309     } catch (std::out_of_range& e) {
54310       {
54311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54312       };
54313     } catch (std::exception& e) {
54314       {
54315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54316       };
54317     } catch (Dali::DaliException e) {
54318       {
54319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54320       };
54321     } catch (...) {
54322       {
54323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54324       };
54325     }
54326   }
54327
54328   jresult = result;
54329   return jresult;
54330 }
54331
54332
54333 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54334   unsigned long jresult ;
54335   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54336   std::size_t result;
54337
54338   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54339   {
54340     try {
54341       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54342     } catch (std::out_of_range& e) {
54343       {
54344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54345       };
54346     } catch (std::exception& e) {
54347       {
54348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54349       };
54350     } catch (Dali::DaliException e) {
54351       {
54352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54353       };
54354     } catch (...) {
54355       {
54356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54357       };
54358     }
54359   }
54360
54361   jresult = (unsigned long)result;
54362   return jresult;
54363 }
54364
54365
54366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54367   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54368   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54369
54370   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54371   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54372   {
54373     try {
54374       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54375     } catch (std::out_of_range& e) {
54376       {
54377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54378       };
54379     } catch (std::exception& e) {
54380       {
54381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (Dali::DaliException e) {
54384       {
54385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54386       };
54387     } catch (...) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54390       };
54391     }
54392   }
54393
54394 }
54395
54396
54397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54398   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54399   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54400
54401   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54402   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54403   {
54404     try {
54405       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54406     } catch (std::out_of_range& e) {
54407       {
54408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54409       };
54410     } catch (std::exception& e) {
54411       {
54412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54413       };
54414     } catch (Dali::DaliException e) {
54415       {
54416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54417       };
54418     } catch (...) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54421       };
54422     }
54423   }
54424
54425 }
54426
54427
54428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54429   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54430   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54431
54432   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54433   arg2 = (Dali::RefObject *)jarg2;
54434   {
54435     try {
54436       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54437     } catch (std::out_of_range& e) {
54438       {
54439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54440       };
54441     } catch (std::exception& e) {
54442       {
54443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54444       };
54445     } catch (Dali::DaliException e) {
54446       {
54447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54448       };
54449     } catch (...) {
54450       {
54451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54452       };
54453     }
54454   }
54455
54456 }
54457
54458
54459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54460   void * jresult ;
54461   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54462
54463   {
54464     try {
54465       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54466     } catch (std::out_of_range& e) {
54467       {
54468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54469       };
54470     } catch (std::exception& e) {
54471       {
54472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54473       };
54474     } catch (Dali::DaliException e) {
54475       {
54476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54477       };
54478     } catch (...) {
54479       {
54480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54481       };
54482     }
54483   }
54484
54485   jresult = (void *)result;
54486   return jresult;
54487 }
54488
54489
54490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54491   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54492
54493   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54494   {
54495     try {
54496       delete arg1;
54497     } catch (std::out_of_range& e) {
54498       {
54499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54500       };
54501     } catch (std::exception& e) {
54502       {
54503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54504       };
54505     } catch (Dali::DaliException e) {
54506       {
54507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54508       };
54509     } catch (...) {
54510       {
54511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54512       };
54513     }
54514   }
54515
54516 }
54517
54518
54519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54520   unsigned int jresult ;
54521   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54522   bool result;
54523
54524   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54525   {
54526     try {
54527       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54528     } catch (std::out_of_range& e) {
54529       {
54530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54531       };
54532     } catch (std::exception& e) {
54533       {
54534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54535       };
54536     } catch (Dali::DaliException e) {
54537       {
54538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54539       };
54540     } catch (...) {
54541       {
54542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54543       };
54544     }
54545   }
54546
54547   jresult = result;
54548   return jresult;
54549 }
54550
54551
54552 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54553   unsigned long jresult ;
54554   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54555   std::size_t result;
54556
54557   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54558   {
54559     try {
54560       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54561     } catch (std::out_of_range& e) {
54562       {
54563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54564       };
54565     } catch (std::exception& e) {
54566       {
54567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54568       };
54569     } catch (Dali::DaliException e) {
54570       {
54571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54572       };
54573     } catch (...) {
54574       {
54575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54576       };
54577     }
54578   }
54579
54580   jresult = (unsigned long)result;
54581   return jresult;
54582 }
54583
54584
54585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54586   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54587   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54588
54589   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54590   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54591   {
54592     try {
54593       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54594     } catch (std::out_of_range& e) {
54595       {
54596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54597       };
54598     } catch (std::exception& e) {
54599       {
54600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54601       };
54602     } catch (Dali::DaliException e) {
54603       {
54604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54605       };
54606     } catch (...) {
54607       {
54608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54609       };
54610     }
54611   }
54612
54613 }
54614
54615
54616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54617   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54618   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54619
54620   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54621   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54622   {
54623     try {
54624       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54625     } catch (std::out_of_range& e) {
54626       {
54627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54628       };
54629     } catch (std::exception& e) {
54630       {
54631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54632       };
54633     } catch (Dali::DaliException e) {
54634       {
54635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54636       };
54637     } catch (...) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54640       };
54641     }
54642   }
54643
54644 }
54645
54646
54647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54648   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54649   Dali::PropertyNotification *arg2 = 0 ;
54650
54651   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54652   arg2 = (Dali::PropertyNotification *)jarg2;
54653   if (!arg2) {
54654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54655     return ;
54656   }
54657   {
54658     try {
54659       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54660     } catch (std::out_of_range& e) {
54661       {
54662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54663       };
54664     } catch (std::exception& e) {
54665       {
54666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54667       };
54668     } catch (Dali::DaliException e) {
54669       {
54670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54671       };
54672     } catch (...) {
54673       {
54674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54675       };
54676     }
54677   }
54678
54679 }
54680
54681
54682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54683   void * jresult ;
54684   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54685
54686   {
54687     try {
54688       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54689     } catch (std::out_of_range& e) {
54690       {
54691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54692       };
54693     } catch (std::exception& e) {
54694       {
54695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54696       };
54697     } catch (Dali::DaliException e) {
54698       {
54699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54700       };
54701     } catch (...) {
54702       {
54703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54704       };
54705     }
54706   }
54707
54708   jresult = (void *)result;
54709   return jresult;
54710 }
54711
54712
54713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54714   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54715
54716   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54717   {
54718     try {
54719       delete arg1;
54720     } catch (std::out_of_range& e) {
54721       {
54722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54723       };
54724     } catch (std::exception& e) {
54725       {
54726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54727       };
54728     } catch (Dali::DaliException e) {
54729       {
54730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54731       };
54732     } catch (...) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54735       };
54736     }
54737   }
54738
54739 }
54740
54741
54742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54743   unsigned int jresult ;
54744   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54745   bool result;
54746
54747   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54748   {
54749     try {
54750       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54751     } catch (std::out_of_range& e) {
54752       {
54753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54754       };
54755     } catch (std::exception& e) {
54756       {
54757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54758       };
54759     } catch (Dali::DaliException e) {
54760       {
54761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54762       };
54763     } catch (...) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54766       };
54767     }
54768   }
54769
54770   jresult = result;
54771   return jresult;
54772 }
54773
54774
54775 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54776   unsigned long jresult ;
54777   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54778   std::size_t result;
54779
54780   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54781   {
54782     try {
54783       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54784     } catch (std::out_of_range& e) {
54785       {
54786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54787       };
54788     } catch (std::exception& e) {
54789       {
54790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (Dali::DaliException e) {
54793       {
54794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54795       };
54796     } catch (...) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54799       };
54800     }
54801   }
54802
54803   jresult = (unsigned long)result;
54804   return jresult;
54805 }
54806
54807
54808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54809   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54810   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54811
54812   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54813   arg2 = (void (*)(Dali::Image))jarg2;
54814   {
54815     try {
54816       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54817     } catch (std::out_of_range& e) {
54818       {
54819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54820       };
54821     } catch (std::exception& e) {
54822       {
54823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54824       };
54825     } catch (Dali::DaliException e) {
54826       {
54827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54828       };
54829     } catch (...) {
54830       {
54831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54832       };
54833     }
54834   }
54835
54836 }
54837
54838
54839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54840   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54841   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54842
54843   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54844   arg2 = (void (*)(Dali::Image))jarg2;
54845   {
54846     try {
54847       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54848     } catch (std::out_of_range& e) {
54849       {
54850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54851       };
54852     } catch (std::exception& e) {
54853       {
54854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54855       };
54856     } catch (Dali::DaliException e) {
54857       {
54858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54859       };
54860     } catch (...) {
54861       {
54862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54863       };
54864     }
54865   }
54866
54867 }
54868
54869
54870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54871   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54872   Dali::Image arg2 ;
54873   Dali::Image *argp2 ;
54874
54875   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54876   argp2 = (Dali::Image *)jarg2;
54877   if (!argp2) {
54878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54879     return ;
54880   }
54881   arg2 = *argp2;
54882   {
54883     try {
54884       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54885     } catch (std::out_of_range& e) {
54886       {
54887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54888       };
54889     } catch (std::exception& e) {
54890       {
54891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54892       };
54893     } catch (Dali::DaliException e) {
54894       {
54895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54896       };
54897     } catch (...) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54900       };
54901     }
54902   }
54903
54904 }
54905
54906
54907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54908   void * jresult ;
54909   Dali::Signal< void (Dali::Image) > *result = 0 ;
54910
54911   {
54912     try {
54913       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54914     } catch (std::out_of_range& e) {
54915       {
54916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54917       };
54918     } catch (std::exception& e) {
54919       {
54920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (Dali::DaliException e) {
54923       {
54924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54925       };
54926     } catch (...) {
54927       {
54928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54929       };
54930     }
54931   }
54932
54933   jresult = (void *)result;
54934   return jresult;
54935 }
54936
54937
54938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54939   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54940
54941   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54942   {
54943     try {
54944       delete arg1;
54945     } catch (std::out_of_range& e) {
54946       {
54947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54948       };
54949     } catch (std::exception& e) {
54950       {
54951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54952       };
54953     } catch (Dali::DaliException e) {
54954       {
54955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54956       };
54957     } catch (...) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54960       };
54961     }
54962   }
54963
54964 }
54965
54966
54967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54968   void * jresult ;
54969   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54970
54971   {
54972     try {
54973       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54974     } catch (std::out_of_range& e) {
54975       {
54976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54977       };
54978     } catch (std::exception& e) {
54979       {
54980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54981       };
54982     } catch (Dali::DaliException e) {
54983       {
54984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54985       };
54986     } catch (...) {
54987       {
54988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54989       };
54990     }
54991   }
54992
54993   jresult = (void *)result;
54994   return jresult;
54995 }
54996
54997
54998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54999   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55000
55001   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55002   {
55003     try {
55004       delete arg1;
55005     } catch (std::out_of_range& e) {
55006       {
55007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55008       };
55009     } catch (std::exception& e) {
55010       {
55011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55012       };
55013     } catch (Dali::DaliException e) {
55014       {
55015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55016       };
55017     } catch (...) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55020       };
55021     }
55022   }
55023
55024 }
55025
55026
55027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55028   unsigned int jresult ;
55029   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55030   bool result;
55031
55032   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55033   {
55034     try {
55035       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);
55036     } catch (std::out_of_range& e) {
55037       {
55038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55039       };
55040     } catch (std::exception& e) {
55041       {
55042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55043       };
55044     } catch (Dali::DaliException e) {
55045       {
55046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55047       };
55048     } catch (...) {
55049       {
55050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55051       };
55052     }
55053   }
55054
55055   jresult = result;
55056   return jresult;
55057 }
55058
55059
55060 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55061   unsigned long jresult ;
55062   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55063   std::size_t result;
55064
55065   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55066   {
55067     try {
55068       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);
55069     } catch (std::out_of_range& e) {
55070       {
55071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55072       };
55073     } catch (std::exception& e) {
55074       {
55075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55076       };
55077     } catch (Dali::DaliException e) {
55078       {
55079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55080       };
55081     } catch (...) {
55082       {
55083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55084       };
55085     }
55086   }
55087
55088   jresult = (unsigned long)result;
55089   return jresult;
55090 }
55091
55092
55093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55094   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55095   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55096
55097   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55098   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55099   {
55100     try {
55101       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55102     } catch (std::out_of_range& e) {
55103       {
55104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55105       };
55106     } catch (std::exception& e) {
55107       {
55108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55109       };
55110     } catch (Dali::DaliException e) {
55111       {
55112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55113       };
55114     } catch (...) {
55115       {
55116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55117       };
55118     }
55119   }
55120
55121 }
55122
55123
55124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55125   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55126   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55127
55128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55129   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55130   {
55131     try {
55132       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55133     } catch (std::out_of_range& e) {
55134       {
55135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55136       };
55137     } catch (std::exception& e) {
55138       {
55139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55140       };
55141     } catch (Dali::DaliException e) {
55142       {
55143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55144       };
55145     } catch (...) {
55146       {
55147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55148       };
55149     }
55150   }
55151
55152 }
55153
55154
55155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55156   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55157   Dali::Actor arg2 ;
55158   Dali::LongPressGesture *arg3 = 0 ;
55159   Dali::Actor *argp2 ;
55160
55161   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55162   argp2 = (Dali::Actor *)jarg2;
55163   if (!argp2) {
55164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55165     return ;
55166   }
55167   arg2 = *argp2;
55168   arg3 = (Dali::LongPressGesture *)jarg3;
55169   if (!arg3) {
55170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55171     return ;
55172   }
55173   {
55174     try {
55175       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55176     } catch (std::out_of_range& e) {
55177       {
55178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55179       };
55180     } catch (std::exception& e) {
55181       {
55182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55183       };
55184     } catch (Dali::DaliException e) {
55185       {
55186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55187       };
55188     } catch (...) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55191       };
55192     }
55193   }
55194
55195 }
55196
55197
55198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55199   void * jresult ;
55200   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55201
55202   {
55203     try {
55204       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55205     } catch (std::out_of_range& e) {
55206       {
55207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55208       };
55209     } catch (std::exception& e) {
55210       {
55211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55212       };
55213     } catch (Dali::DaliException e) {
55214       {
55215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55216       };
55217     } catch (...) {
55218       {
55219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55220       };
55221     }
55222   }
55223
55224   jresult = (void *)result;
55225   return jresult;
55226 }
55227
55228
55229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55230   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55231
55232   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55233   {
55234     try {
55235       delete arg1;
55236     } catch (std::out_of_range& e) {
55237       {
55238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55239       };
55240     } catch (std::exception& e) {
55241       {
55242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55243       };
55244     } catch (Dali::DaliException e) {
55245       {
55246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55247       };
55248     } catch (...) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55251       };
55252     }
55253   }
55254
55255 }
55256
55257
55258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55259   unsigned int jresult ;
55260   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55261   bool result;
55262
55263   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55264   {
55265     try {
55266       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);
55267     } catch (std::out_of_range& e) {
55268       {
55269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55270       };
55271     } catch (std::exception& e) {
55272       {
55273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55274       };
55275     } catch (Dali::DaliException e) {
55276       {
55277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55278       };
55279     } catch (...) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55282       };
55283     }
55284   }
55285
55286   jresult = result;
55287   return jresult;
55288 }
55289
55290
55291 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55292   unsigned long jresult ;
55293   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55294   std::size_t result;
55295
55296   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55297   {
55298     try {
55299       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);
55300     } catch (std::out_of_range& e) {
55301       {
55302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55303       };
55304     } catch (std::exception& e) {
55305       {
55306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (Dali::DaliException e) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55311       };
55312     } catch (...) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55315       };
55316     }
55317   }
55318
55319   jresult = (unsigned long)result;
55320   return jresult;
55321 }
55322
55323
55324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55325   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55326   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55327
55328   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55329   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55330   {
55331     try {
55332       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55333     } catch (std::out_of_range& e) {
55334       {
55335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55336       };
55337     } catch (std::exception& e) {
55338       {
55339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55340       };
55341     } catch (Dali::DaliException e) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55344       };
55345     } catch (...) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55348       };
55349     }
55350   }
55351
55352 }
55353
55354
55355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55356   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55357   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55358
55359   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55360   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55361   {
55362     try {
55363       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55364     } catch (std::out_of_range& e) {
55365       {
55366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55367       };
55368     } catch (std::exception& e) {
55369       {
55370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55371       };
55372     } catch (Dali::DaliException e) {
55373       {
55374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55375       };
55376     } catch (...) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55379       };
55380     }
55381   }
55382
55383 }
55384
55385
55386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55387   unsigned int jresult ;
55388   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55389   Dali::Actor arg2 ;
55390   Dali::TouchData *arg3 = 0 ;
55391   Dali::Actor *argp2 ;
55392   bool result;
55393
55394   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55395   argp2 = (Dali::Actor *)jarg2;
55396   if (!argp2) {
55397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55398     return 0;
55399   }
55400   arg2 = *argp2;
55401   arg3 = (Dali::TouchData *)jarg3;
55402   if (!arg3) {
55403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55404     return 0;
55405   }
55406   {
55407     try {
55408       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55409     } catch (std::out_of_range& e) {
55410       {
55411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55412       };
55413     } catch (std::exception& e) {
55414       {
55415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (Dali::DaliException e) {
55418       {
55419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55420       };
55421     } catch (...) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55424       };
55425     }
55426   }
55427
55428   jresult = result;
55429   return jresult;
55430 }
55431
55432
55433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55434   void * jresult ;
55435   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55436
55437   {
55438     try {
55439       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55440     } catch (std::out_of_range& e) {
55441       {
55442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55443       };
55444     } catch (std::exception& e) {
55445       {
55446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55447       };
55448     } catch (Dali::DaliException e) {
55449       {
55450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55451       };
55452     } catch (...) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55455       };
55456     }
55457   }
55458
55459   jresult = (void *)result;
55460   return jresult;
55461 }
55462
55463
55464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55465   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55466
55467   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55468   {
55469     try {
55470       delete arg1;
55471     } catch (std::out_of_range& e) {
55472       {
55473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55474       };
55475     } catch (std::exception& e) {
55476       {
55477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55478       };
55479     } catch (Dali::DaliException e) {
55480       {
55481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55482       };
55483     } catch (...) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55486       };
55487     }
55488   }
55489
55490 }
55491
55492
55493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55494   unsigned int jresult ;
55495   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55496   bool result;
55497
55498   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55499   {
55500     try {
55501       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);
55502     } catch (std::out_of_range& e) {
55503       {
55504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55505       };
55506     } catch (std::exception& e) {
55507       {
55508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (Dali::DaliException e) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55513       };
55514     } catch (...) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55517       };
55518     }
55519   }
55520
55521   jresult = result;
55522   return jresult;
55523 }
55524
55525
55526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55527   unsigned long jresult ;
55528   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55529   std::size_t result;
55530
55531   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55532   {
55533     try {
55534       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);
55535     } catch (std::out_of_range& e) {
55536       {
55537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55538       };
55539     } catch (std::exception& e) {
55540       {
55541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55542       };
55543     } catch (Dali::DaliException e) {
55544       {
55545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55546       };
55547     } catch (...) {
55548       {
55549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55550       };
55551     }
55552   }
55553
55554   jresult = (unsigned long)result;
55555   return jresult;
55556 }
55557
55558
55559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55560   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55561   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55562
55563   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55564   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55565   {
55566     try {
55567       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55568     } catch (std::out_of_range& e) {
55569       {
55570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55571       };
55572     } catch (std::exception& e) {
55573       {
55574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55575       };
55576     } catch (Dali::DaliException e) {
55577       {
55578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55579       };
55580     } catch (...) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55583       };
55584     }
55585   }
55586
55587 }
55588
55589
55590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55591   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55592   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55593
55594   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55595   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55596   {
55597     try {
55598       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55599     } catch (std::out_of_range& e) {
55600       {
55601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55602       };
55603     } catch (std::exception& e) {
55604       {
55605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55606       };
55607     } catch (Dali::DaliException e) {
55608       {
55609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55610       };
55611     } catch (...) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55614       };
55615     }
55616   }
55617
55618 }
55619
55620
55621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55622   unsigned int jresult ;
55623   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55624   Dali::Actor arg2 ;
55625   Dali::HoverEvent *arg3 = 0 ;
55626   Dali::Actor *argp2 ;
55627   bool result;
55628
55629   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55630   argp2 = (Dali::Actor *)jarg2;
55631   if (!argp2) {
55632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55633     return 0;
55634   }
55635   arg2 = *argp2;
55636   arg3 = (Dali::HoverEvent *)jarg3;
55637   if (!arg3) {
55638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55639     return 0;
55640   }
55641   {
55642     try {
55643       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55644     } catch (std::out_of_range& e) {
55645       {
55646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55647       };
55648     } catch (std::exception& e) {
55649       {
55650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55651       };
55652     } catch (Dali::DaliException e) {
55653       {
55654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55655       };
55656     } catch (...) {
55657       {
55658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55659       };
55660     }
55661   }
55662
55663   jresult = result;
55664   return jresult;
55665 }
55666
55667
55668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55669   void * jresult ;
55670   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55671
55672   {
55673     try {
55674       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55675     } catch (std::out_of_range& e) {
55676       {
55677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55678       };
55679     } catch (std::exception& e) {
55680       {
55681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (Dali::DaliException e) {
55684       {
55685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55686       };
55687     } catch (...) {
55688       {
55689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55690       };
55691     }
55692   }
55693
55694   jresult = (void *)result;
55695   return jresult;
55696 }
55697
55698
55699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55700   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55701
55702   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55703   {
55704     try {
55705       delete arg1;
55706     } catch (std::out_of_range& e) {
55707       {
55708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55709       };
55710     } catch (std::exception& e) {
55711       {
55712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55713       };
55714     } catch (Dali::DaliException e) {
55715       {
55716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55717       };
55718     } catch (...) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55721       };
55722     }
55723   }
55724
55725 }
55726
55727
55728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55729   unsigned int jresult ;
55730   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55731   bool result;
55732
55733   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55734   {
55735     try {
55736       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);
55737     } catch (std::out_of_range& e) {
55738       {
55739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55740       };
55741     } catch (std::exception& e) {
55742       {
55743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (Dali::DaliException e) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55748       };
55749     } catch (...) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55752       };
55753     }
55754   }
55755
55756   jresult = result;
55757   return jresult;
55758 }
55759
55760
55761 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55762   unsigned long jresult ;
55763   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55764   std::size_t result;
55765
55766   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55767   {
55768     try {
55769       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);
55770     } catch (std::out_of_range& e) {
55771       {
55772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55773       };
55774     } catch (std::exception& e) {
55775       {
55776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55777       };
55778     } catch (Dali::DaliException e) {
55779       {
55780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55781       };
55782     } catch (...) {
55783       {
55784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55785       };
55786     }
55787   }
55788
55789   jresult = (unsigned long)result;
55790   return jresult;
55791 }
55792
55793
55794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55795   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55796   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55797
55798   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55799   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55800   {
55801     try {
55802       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55803     } catch (std::out_of_range& e) {
55804       {
55805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55806       };
55807     } catch (std::exception& e) {
55808       {
55809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55810       };
55811     } catch (Dali::DaliException e) {
55812       {
55813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55814       };
55815     } catch (...) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55818       };
55819     }
55820   }
55821
55822 }
55823
55824
55825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55826   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55827   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55828
55829   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55830   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55831   {
55832     try {
55833       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55834     } catch (std::out_of_range& e) {
55835       {
55836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55837       };
55838     } catch (std::exception& e) {
55839       {
55840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55841       };
55842     } catch (Dali::DaliException e) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55845       };
55846     } catch (...) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55849       };
55850     }
55851   }
55852
55853 }
55854
55855
55856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55857   unsigned int jresult ;
55858   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55859   Dali::Actor arg2 ;
55860   Dali::WheelEvent *arg3 = 0 ;
55861   Dali::Actor *argp2 ;
55862   bool result;
55863
55864   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55865   argp2 = (Dali::Actor *)jarg2;
55866   if (!argp2) {
55867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55868     return 0;
55869   }
55870   arg2 = *argp2;
55871   arg3 = (Dali::WheelEvent *)jarg3;
55872   if (!arg3) {
55873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55874     return 0;
55875   }
55876   {
55877     try {
55878       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55879     } catch (std::out_of_range& e) {
55880       {
55881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55882       };
55883     } catch (std::exception& e) {
55884       {
55885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55886       };
55887     } catch (Dali::DaliException e) {
55888       {
55889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55890       };
55891     } catch (...) {
55892       {
55893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55894       };
55895     }
55896   }
55897
55898   jresult = result;
55899   return jresult;
55900 }
55901
55902
55903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55904   void * jresult ;
55905   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55906
55907   {
55908     try {
55909       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55910     } catch (std::out_of_range& e) {
55911       {
55912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55913       };
55914     } catch (std::exception& e) {
55915       {
55916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55917       };
55918     } catch (Dali::DaliException e) {
55919       {
55920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55921       };
55922     } catch (...) {
55923       {
55924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55925       };
55926     }
55927   }
55928
55929   jresult = (void *)result;
55930   return jresult;
55931 }
55932
55933
55934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55935   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55936
55937   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55938   {
55939     try {
55940       delete arg1;
55941     } catch (std::out_of_range& e) {
55942       {
55943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55944       };
55945     } catch (std::exception& e) {
55946       {
55947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55948       };
55949     } catch (Dali::DaliException e) {
55950       {
55951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55952       };
55953     } catch (...) {
55954       {
55955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55956       };
55957     }
55958   }
55959
55960 }
55961
55962
55963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55964   unsigned int jresult ;
55965   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55966   bool result;
55967
55968   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55969   {
55970     try {
55971       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55972     } catch (std::out_of_range& e) {
55973       {
55974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55975       };
55976     } catch (std::exception& e) {
55977       {
55978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55979       };
55980     } catch (Dali::DaliException e) {
55981       {
55982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55983       };
55984     } catch (...) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55987       };
55988     }
55989   }
55990
55991   jresult = result;
55992   return jresult;
55993 }
55994
55995
55996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55997   unsigned long jresult ;
55998   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55999   std::size_t result;
56000
56001   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56002   {
56003     try {
56004       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56005     } catch (std::out_of_range& e) {
56006       {
56007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56008       };
56009     } catch (std::exception& e) {
56010       {
56011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56012       };
56013     } catch (Dali::DaliException e) {
56014       {
56015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56016       };
56017     } catch (...) {
56018       {
56019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56020       };
56021     }
56022   }
56023
56024   jresult = (unsigned long)result;
56025   return jresult;
56026 }
56027
56028
56029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56030   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56031   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56032
56033   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56034   arg2 = (void (*)(Dali::Actor))jarg2;
56035   {
56036     try {
56037       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56038     } catch (std::out_of_range& e) {
56039       {
56040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56041       };
56042     } catch (std::exception& e) {
56043       {
56044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56045       };
56046     } catch (Dali::DaliException e) {
56047       {
56048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56049       };
56050     } catch (...) {
56051       {
56052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56053       };
56054     }
56055   }
56056
56057 }
56058
56059
56060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56061   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56062   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56063
56064   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56065   arg2 = (void (*)(Dali::Actor))jarg2;
56066   {
56067     try {
56068       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56069     } catch (std::out_of_range& e) {
56070       {
56071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56072       };
56073     } catch (std::exception& e) {
56074       {
56075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56076       };
56077     } catch (Dali::DaliException e) {
56078       {
56079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56080       };
56081     } catch (...) {
56082       {
56083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56084       };
56085     }
56086   }
56087
56088 }
56089
56090
56091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56092   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56093   Dali::Actor arg2 ;
56094   Dali::Actor *argp2 ;
56095
56096   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56097   argp2 = (Dali::Actor *)jarg2;
56098   if (!argp2) {
56099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56100     return ;
56101   }
56102   arg2 = *argp2;
56103   {
56104     try {
56105       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56106     } catch (std::out_of_range& e) {
56107       {
56108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56109       };
56110     } catch (std::exception& e) {
56111       {
56112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (Dali::DaliException e) {
56115       {
56116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56117       };
56118     } catch (...) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56121       };
56122     }
56123   }
56124
56125 }
56126
56127
56128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56129   void * jresult ;
56130   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56131
56132   {
56133     try {
56134       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56135     } catch (std::out_of_range& e) {
56136       {
56137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56138       };
56139     } catch (std::exception& e) {
56140       {
56141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56142       };
56143     } catch (Dali::DaliException e) {
56144       {
56145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56146       };
56147     } catch (...) {
56148       {
56149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56150       };
56151     }
56152   }
56153
56154   jresult = (void *)result;
56155   return jresult;
56156 }
56157
56158
56159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56160   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56161
56162   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56163   {
56164     try {
56165       delete arg1;
56166     } catch (std::out_of_range& e) {
56167       {
56168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56169       };
56170     } catch (std::exception& e) {
56171       {
56172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56173       };
56174     } catch (Dali::DaliException e) {
56175       {
56176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56177       };
56178     } catch (...) {
56179       {
56180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56181       };
56182     }
56183   }
56184
56185 }
56186
56187
56188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56189   unsigned int jresult ;
56190   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56191   bool result;
56192
56193   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56194   {
56195     try {
56196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56197     } catch (std::out_of_range& e) {
56198       {
56199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56200       };
56201     } catch (std::exception& e) {
56202       {
56203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56204       };
56205     } catch (Dali::DaliException e) {
56206       {
56207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56208       };
56209     } catch (...) {
56210       {
56211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56212       };
56213     }
56214   }
56215
56216   jresult = result;
56217   return jresult;
56218 }
56219
56220
56221 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56222   unsigned long jresult ;
56223   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56224   std::size_t result;
56225
56226   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56227   {
56228     try {
56229       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56230     } catch (std::out_of_range& e) {
56231       {
56232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56233       };
56234     } catch (std::exception& e) {
56235       {
56236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (Dali::DaliException e) {
56239       {
56240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248
56249   jresult = (unsigned long)result;
56250   return jresult;
56251 }
56252
56253
56254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56255   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56256   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56257
56258   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56259   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56260   {
56261     try {
56262       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56263     } catch (std::out_of_range& e) {
56264       {
56265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56266       };
56267     } catch (std::exception& e) {
56268       {
56269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56270       };
56271     } catch (Dali::DaliException e) {
56272       {
56273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56274       };
56275     } catch (...) {
56276       {
56277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56278       };
56279     }
56280   }
56281
56282 }
56283
56284
56285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56286   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56287   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56288
56289   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56290   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56291   {
56292     try {
56293       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56294     } catch (std::out_of_range& e) {
56295       {
56296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56297       };
56298     } catch (std::exception& e) {
56299       {
56300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56301       };
56302     } catch (Dali::DaliException e) {
56303       {
56304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56305       };
56306     } catch (...) {
56307       {
56308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56309       };
56310     }
56311   }
56312
56313 }
56314
56315
56316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56317   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56318   Dali::KeyEvent *arg2 = 0 ;
56319
56320   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56321   arg2 = (Dali::KeyEvent *)jarg2;
56322   if (!arg2) {
56323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56324     return ;
56325   }
56326   {
56327     try {
56328       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56329     } catch (std::out_of_range& e) {
56330       {
56331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56332       };
56333     } catch (std::exception& e) {
56334       {
56335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56336       };
56337     } catch (Dali::DaliException e) {
56338       {
56339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56340       };
56341     } catch (...) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56344       };
56345     }
56346   }
56347
56348 }
56349
56350
56351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56352   void * jresult ;
56353   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56354
56355   {
56356     try {
56357       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56358     } catch (std::out_of_range& e) {
56359       {
56360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56361       };
56362     } catch (std::exception& e) {
56363       {
56364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56365       };
56366     } catch (Dali::DaliException e) {
56367       {
56368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56369       };
56370     } catch (...) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56373       };
56374     }
56375   }
56376
56377   jresult = (void *)result;
56378   return jresult;
56379 }
56380
56381
56382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56383   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56384
56385   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56386   {
56387     try {
56388       delete arg1;
56389     } catch (std::out_of_range& e) {
56390       {
56391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56392       };
56393     } catch (std::exception& e) {
56394       {
56395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56396       };
56397     } catch (Dali::DaliException e) {
56398       {
56399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56400       };
56401     } catch (...) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56404       };
56405     }
56406   }
56407
56408 }
56409
56410
56411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56412   unsigned int jresult ;
56413   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56414   bool result;
56415
56416   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56417   {
56418     try {
56419       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56420     } catch (std::out_of_range& e) {
56421       {
56422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56423       };
56424     } catch (std::exception& e) {
56425       {
56426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56427       };
56428     } catch (Dali::DaliException e) {
56429       {
56430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56431       };
56432     } catch (...) {
56433       {
56434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56435       };
56436     }
56437   }
56438
56439   jresult = result;
56440   return jresult;
56441 }
56442
56443
56444 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56445   unsigned long jresult ;
56446   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56447   std::size_t result;
56448
56449   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56450   {
56451     try {
56452       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56453     } catch (std::out_of_range& e) {
56454       {
56455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56456       };
56457     } catch (std::exception& e) {
56458       {
56459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (Dali::DaliException e) {
56462       {
56463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56464       };
56465     } catch (...) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56468       };
56469     }
56470   }
56471
56472   jresult = (unsigned long)result;
56473   return jresult;
56474 }
56475
56476
56477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56478   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56479   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56480
56481   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56482   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56483   {
56484     try {
56485       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56486     } catch (std::out_of_range& e) {
56487       {
56488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56489       };
56490     } catch (std::exception& e) {
56491       {
56492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56493       };
56494     } catch (Dali::DaliException e) {
56495       {
56496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56497       };
56498     } catch (...) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56501       };
56502     }
56503   }
56504
56505 }
56506
56507
56508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56509   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56510   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56511
56512   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56513   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56514   {
56515     try {
56516       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56517     } catch (std::out_of_range& e) {
56518       {
56519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56520       };
56521     } catch (std::exception& e) {
56522       {
56523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56524       };
56525     } catch (Dali::DaliException e) {
56526       {
56527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56528       };
56529     } catch (...) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56532       };
56533     }
56534   }
56535
56536 }
56537
56538
56539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56540   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56541   Dali::TouchData *arg2 = 0 ;
56542
56543   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56544   arg2 = (Dali::TouchData *)jarg2;
56545   if (!arg2) {
56546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56547     return ;
56548   }
56549   {
56550     try {
56551       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56552     } catch (std::out_of_range& e) {
56553       {
56554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56555       };
56556     } catch (std::exception& e) {
56557       {
56558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56559       };
56560     } catch (Dali::DaliException e) {
56561       {
56562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56563       };
56564     } catch (...) {
56565       {
56566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56567       };
56568     }
56569   }
56570
56571 }
56572
56573
56574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56575   void * jresult ;
56576   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56577
56578   {
56579     try {
56580       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56581     } catch (std::out_of_range& e) {
56582       {
56583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56584       };
56585     } catch (std::exception& e) {
56586       {
56587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (Dali::DaliException e) {
56590       {
56591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56592       };
56593     } catch (...) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56596       };
56597     }
56598   }
56599
56600   jresult = (void *)result;
56601   return jresult;
56602 }
56603
56604
56605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56606   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56607
56608   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56609   {
56610     try {
56611       delete arg1;
56612     } catch (std::out_of_range& e) {
56613       {
56614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56615       };
56616     } catch (std::exception& e) {
56617       {
56618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56619       };
56620     } catch (Dali::DaliException e) {
56621       {
56622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56623       };
56624     } catch (...) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56627       };
56628     }
56629   }
56630
56631 }
56632
56633
56634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56635   unsigned int jresult ;
56636   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56637   bool result;
56638
56639   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56640   {
56641     try {
56642       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56643     } catch (std::out_of_range& e) {
56644       {
56645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56646       };
56647     } catch (std::exception& e) {
56648       {
56649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (Dali::DaliException e) {
56652       {
56653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56654       };
56655     } catch (...) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56658       };
56659     }
56660   }
56661
56662   jresult = result;
56663   return jresult;
56664 }
56665
56666
56667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56668   unsigned long jresult ;
56669   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56670   std::size_t result;
56671
56672   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56673   {
56674     try {
56675       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56676     } catch (std::out_of_range& e) {
56677       {
56678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56679       };
56680     } catch (std::exception& e) {
56681       {
56682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56683       };
56684     } catch (Dali::DaliException e) {
56685       {
56686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56687       };
56688     } catch (...) {
56689       {
56690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56691       };
56692     }
56693   }
56694
56695   jresult = (unsigned long)result;
56696   return jresult;
56697 }
56698
56699
56700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56701   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56702   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56703
56704   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56705   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56706   {
56707     try {
56708       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56709     } catch (std::out_of_range& e) {
56710       {
56711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56712       };
56713     } catch (std::exception& e) {
56714       {
56715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56716       };
56717     } catch (Dali::DaliException e) {
56718       {
56719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56720       };
56721     } catch (...) {
56722       {
56723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56724       };
56725     }
56726   }
56727
56728 }
56729
56730
56731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56732   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56733   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56734
56735   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56736   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56737   {
56738     try {
56739       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56740     } catch (std::out_of_range& e) {
56741       {
56742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56743       };
56744     } catch (std::exception& e) {
56745       {
56746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56747       };
56748     } catch (Dali::DaliException e) {
56749       {
56750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56755       };
56756     }
56757   }
56758
56759 }
56760
56761
56762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56763   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56764   Dali::WheelEvent *arg2 = 0 ;
56765
56766   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56767   arg2 = (Dali::WheelEvent *)jarg2;
56768   if (!arg2) {
56769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56770     return ;
56771   }
56772   {
56773     try {
56774       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56775     } catch (std::out_of_range& e) {
56776       {
56777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (std::exception& e) {
56780       {
56781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56782       };
56783     } catch (Dali::DaliException e) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56786       };
56787     } catch (...) {
56788       {
56789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56790       };
56791     }
56792   }
56793
56794 }
56795
56796
56797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56798   void * jresult ;
56799   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56800
56801   {
56802     try {
56803       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56804     } catch (std::out_of_range& e) {
56805       {
56806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56807       };
56808     } catch (std::exception& e) {
56809       {
56810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56811       };
56812     } catch (Dali::DaliException e) {
56813       {
56814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56815       };
56816     } catch (...) {
56817       {
56818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56819       };
56820     }
56821   }
56822
56823   jresult = (void *)result;
56824   return jresult;
56825 }
56826
56827
56828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56829   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56830
56831   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56832   {
56833     try {
56834       delete arg1;
56835     } catch (std::out_of_range& e) {
56836       {
56837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56838       };
56839     } catch (std::exception& e) {
56840       {
56841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56842       };
56843     } catch (Dali::DaliException e) {
56844       {
56845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56846       };
56847     } catch (...) {
56848       {
56849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56850       };
56851     }
56852   }
56853
56854 }
56855
56856
56857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56858   void * jresult ;
56859   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56860
56861   {
56862     try {
56863       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56864     } catch (std::out_of_range& e) {
56865       {
56866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56867       };
56868     } catch (std::exception& e) {
56869       {
56870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56871       };
56872     } catch (Dali::DaliException e) {
56873       {
56874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56875       };
56876     } catch (...) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56879       };
56880     }
56881   }
56882
56883   jresult = (void *)result;
56884   return jresult;
56885 }
56886
56887
56888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56889   void * jresult ;
56890   Dali::Radian arg1 ;
56891   Dali::Radian arg2 ;
56892   Dali::Radian *argp1 ;
56893   Dali::Radian *argp2 ;
56894   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56895
56896   argp1 = (Dali::Radian *)jarg1;
56897   if (!argp1) {
56898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56899     return 0;
56900   }
56901   arg1 = *argp1;
56902   argp2 = (Dali::Radian *)jarg2;
56903   if (!argp2) {
56904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56905     return 0;
56906   }
56907   arg2 = *argp2;
56908   {
56909     try {
56910       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56911     } catch (std::out_of_range& e) {
56912       {
56913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56914       };
56915     } catch (std::exception& e) {
56916       {
56917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56918       };
56919     } catch (Dali::DaliException e) {
56920       {
56921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56922       };
56923     } catch (...) {
56924       {
56925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56926       };
56927     }
56928   }
56929
56930   jresult = (void *)result;
56931   return jresult;
56932 }
56933
56934
56935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56936   void * jresult ;
56937   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56938   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56939
56940   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56941   if (!arg1) {
56942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56943     return 0;
56944   }
56945   {
56946     try {
56947       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56948     } catch (std::out_of_range& e) {
56949       {
56950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56951       };
56952     } catch (std::exception& e) {
56953       {
56954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (Dali::DaliException e) {
56957       {
56958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56959       };
56960     } catch (...) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56963       };
56964     }
56965   }
56966
56967   jresult = (void *)result;
56968   return jresult;
56969 }
56970
56971
56972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56973   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56974   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56975
56976   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56977   arg2 = (Dali::Radian *)jarg2;
56978   if (arg1) (arg1)->first = *arg2;
56979 }
56980
56981
56982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56983   void * jresult ;
56984   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56985   Dali::Radian *result = 0 ;
56986
56987   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56988   result = (Dali::Radian *)& ((arg1)->first);
56989   jresult = (void *)result;
56990   return jresult;
56991 }
56992
56993
56994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56995   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56996   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56997
56998   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56999   arg2 = (Dali::Radian *)jarg2;
57000   if (arg1) (arg1)->second = *arg2;
57001 }
57002
57003
57004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57005   void * jresult ;
57006   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57007   Dali::Radian *result = 0 ;
57008
57009   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57010   result = (Dali::Radian *)& ((arg1)->second);
57011   jresult = (void *)result;
57012   return jresult;
57013 }
57014
57015
57016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57017   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57018
57019   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57020   {
57021     try {
57022       delete arg1;
57023     } catch (std::out_of_range& e) {
57024       {
57025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57026       };
57027     } catch (std::exception& e) {
57028       {
57029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57030       };
57031     } catch (Dali::DaliException e) {
57032       {
57033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57034       };
57035     } catch (...) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57038       };
57039     }
57040   }
57041
57042 }
57043
57044
57045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57046   unsigned int jresult ;
57047   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57048   bool result;
57049
57050   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57051   {
57052     try {
57053       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);
57054     } catch (std::out_of_range& e) {
57055       {
57056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57057       };
57058     } catch (std::exception& e) {
57059       {
57060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57061       };
57062     } catch (Dali::DaliException e) {
57063       {
57064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57065       };
57066     } catch (...) {
57067       {
57068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57069       };
57070     }
57071   }
57072
57073   jresult = result;
57074   return jresult;
57075 }
57076
57077
57078 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57079   unsigned long jresult ;
57080   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57081   std::size_t result;
57082
57083   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57084   {
57085     try {
57086       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);
57087     } catch (std::out_of_range& e) {
57088       {
57089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57090       };
57091     } catch (std::exception& e) {
57092       {
57093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57094       };
57095     } catch (Dali::DaliException e) {
57096       {
57097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57098       };
57099     } catch (...) {
57100       {
57101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57102       };
57103     }
57104   }
57105
57106   jresult = (unsigned long)result;
57107   return jresult;
57108 }
57109
57110
57111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57112   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57113   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57114
57115   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57116   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57117   {
57118     try {
57119       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57120     } catch (std::out_of_range& e) {
57121       {
57122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57123       };
57124     } catch (std::exception& e) {
57125       {
57126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57127       };
57128     } catch (Dali::DaliException e) {
57129       {
57130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57131       };
57132     } catch (...) {
57133       {
57134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57135       };
57136     }
57137   }
57138
57139 }
57140
57141
57142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57143   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57144   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57145
57146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57147   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57148   {
57149     try {
57150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57151     } catch (std::out_of_range& e) {
57152       {
57153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57154       };
57155     } catch (std::exception& e) {
57156       {
57157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57158       };
57159     } catch (Dali::DaliException e) {
57160       {
57161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57162       };
57163     } catch (...) {
57164       {
57165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57166       };
57167     }
57168   }
57169
57170 }
57171
57172
57173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57174   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57175   Dali::Actor arg2 ;
57176   Dali::PanGesture *arg3 = 0 ;
57177   Dali::Actor *argp2 ;
57178
57179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57180   argp2 = (Dali::Actor *)jarg2;
57181   if (!argp2) {
57182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57183     return ;
57184   }
57185   arg2 = *argp2;
57186   arg3 = (Dali::PanGesture *)jarg3;
57187   if (!arg3) {
57188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57189     return ;
57190   }
57191   {
57192     try {
57193       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57194     } catch (std::out_of_range& e) {
57195       {
57196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57197       };
57198     } catch (std::exception& e) {
57199       {
57200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57201       };
57202     } catch (Dali::DaliException e) {
57203       {
57204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57205       };
57206     } catch (...) {
57207       {
57208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57209       };
57210     }
57211   }
57212
57213 }
57214
57215
57216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57217   void * jresult ;
57218   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57219
57220   {
57221     try {
57222       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57223     } catch (std::out_of_range& e) {
57224       {
57225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57226       };
57227     } catch (std::exception& e) {
57228       {
57229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57230       };
57231     } catch (Dali::DaliException e) {
57232       {
57233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57234       };
57235     } catch (...) {
57236       {
57237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57238       };
57239     }
57240   }
57241
57242   jresult = (void *)result;
57243   return jresult;
57244 }
57245
57246
57247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57248   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57249
57250   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57251   {
57252     try {
57253       delete arg1;
57254     } catch (std::out_of_range& e) {
57255       {
57256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57257       };
57258     } catch (std::exception& e) {
57259       {
57260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57261       };
57262     } catch (Dali::DaliException e) {
57263       {
57264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57265       };
57266     } catch (...) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57269       };
57270     }
57271   }
57272
57273 }
57274
57275
57276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57277   unsigned int jresult ;
57278   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57279   bool result;
57280
57281   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57282   {
57283     try {
57284       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);
57285     } catch (std::out_of_range& e) {
57286       {
57287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (std::exception& e) {
57290       {
57291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (Dali::DaliException e) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57296       };
57297     } catch (...) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57300       };
57301     }
57302   }
57303
57304   jresult = result;
57305   return jresult;
57306 }
57307
57308
57309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57310   unsigned long jresult ;
57311   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57312   std::size_t result;
57313
57314   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57315   {
57316     try {
57317       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);
57318     } catch (std::out_of_range& e) {
57319       {
57320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57321       };
57322     } catch (std::exception& e) {
57323       {
57324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57325       };
57326     } catch (Dali::DaliException e) {
57327       {
57328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57329       };
57330     } catch (...) {
57331       {
57332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57333       };
57334     }
57335   }
57336
57337   jresult = (unsigned long)result;
57338   return jresult;
57339 }
57340
57341
57342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57343   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57344   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57345
57346   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57347   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57348   {
57349     try {
57350       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57351     } catch (std::out_of_range& e) {
57352       {
57353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57354       };
57355     } catch (std::exception& e) {
57356       {
57357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57358       };
57359     } catch (Dali::DaliException e) {
57360       {
57361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57362       };
57363     } catch (...) {
57364       {
57365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57366       };
57367     }
57368   }
57369
57370 }
57371
57372
57373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57374   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57375   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57376
57377   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57378   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57379   {
57380     try {
57381       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57382     } catch (std::out_of_range& e) {
57383       {
57384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57385       };
57386     } catch (std::exception& e) {
57387       {
57388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57389       };
57390     } catch (Dali::DaliException e) {
57391       {
57392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57393       };
57394     } catch (...) {
57395       {
57396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57397       };
57398     }
57399   }
57400
57401 }
57402
57403
57404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57405   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57406   Dali::Actor arg2 ;
57407   Dali::PinchGesture *arg3 = 0 ;
57408   Dali::Actor *argp2 ;
57409
57410   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57411   argp2 = (Dali::Actor *)jarg2;
57412   if (!argp2) {
57413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57414     return ;
57415   }
57416   arg2 = *argp2;
57417   arg3 = (Dali::PinchGesture *)jarg3;
57418   if (!arg3) {
57419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57420     return ;
57421   }
57422   {
57423     try {
57424       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57425     } catch (std::out_of_range& e) {
57426       {
57427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57428       };
57429     } catch (std::exception& e) {
57430       {
57431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57432       };
57433     } catch (Dali::DaliException e) {
57434       {
57435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57436       };
57437     } catch (...) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57440       };
57441     }
57442   }
57443
57444 }
57445
57446
57447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57448   void * jresult ;
57449   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57450
57451   {
57452     try {
57453       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57454     } catch (std::out_of_range& e) {
57455       {
57456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (std::exception& e) {
57459       {
57460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (Dali::DaliException e) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57465       };
57466     } catch (...) {
57467       {
57468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57469       };
57470     }
57471   }
57472
57473   jresult = (void *)result;
57474   return jresult;
57475 }
57476
57477
57478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57479   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57480
57481   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57482   {
57483     try {
57484       delete arg1;
57485     } catch (std::out_of_range& e) {
57486       {
57487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57488       };
57489     } catch (std::exception& e) {
57490       {
57491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57492       };
57493     } catch (Dali::DaliException e) {
57494       {
57495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57496       };
57497     } catch (...) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57500       };
57501     }
57502   }
57503
57504 }
57505
57506
57507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57508   unsigned int jresult ;
57509   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57510   bool result;
57511
57512   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57513   {
57514     try {
57515       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);
57516     } catch (std::out_of_range& e) {
57517       {
57518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57519       };
57520     } catch (std::exception& e) {
57521       {
57522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (Dali::DaliException e) {
57525       {
57526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57527       };
57528     } catch (...) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57531       };
57532     }
57533   }
57534
57535   jresult = result;
57536   return jresult;
57537 }
57538
57539
57540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57541   unsigned long jresult ;
57542   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57543   std::size_t result;
57544
57545   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57546   {
57547     try {
57548       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);
57549     } catch (std::out_of_range& e) {
57550       {
57551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57552       };
57553     } catch (std::exception& e) {
57554       {
57555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57556       };
57557     } catch (Dali::DaliException e) {
57558       {
57559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57560       };
57561     } catch (...) {
57562       {
57563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57564       };
57565     }
57566   }
57567
57568   jresult = (unsigned long)result;
57569   return jresult;
57570 }
57571
57572
57573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57574   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57575   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57576
57577   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57578   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57579   {
57580     try {
57581       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57582     } catch (std::out_of_range& e) {
57583       {
57584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57585       };
57586     } catch (std::exception& e) {
57587       {
57588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57589       };
57590     } catch (Dali::DaliException e) {
57591       {
57592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57593       };
57594     } catch (...) {
57595       {
57596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57597       };
57598     }
57599   }
57600
57601 }
57602
57603
57604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57605   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57606   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57607
57608   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57609   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57610   {
57611     try {
57612       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57613     } catch (std::out_of_range& e) {
57614       {
57615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57616       };
57617     } catch (std::exception& e) {
57618       {
57619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57620       };
57621     } catch (Dali::DaliException e) {
57622       {
57623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57624       };
57625     } catch (...) {
57626       {
57627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57628       };
57629     }
57630   }
57631
57632 }
57633
57634
57635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57636   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57637   Dali::Actor arg2 ;
57638   Dali::TapGesture *arg3 = 0 ;
57639   Dali::Actor *argp2 ;
57640
57641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57642   argp2 = (Dali::Actor *)jarg2;
57643   if (!argp2) {
57644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57645     return ;
57646   }
57647   arg2 = *argp2;
57648   arg3 = (Dali::TapGesture *)jarg3;
57649   if (!arg3) {
57650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57651     return ;
57652   }
57653   {
57654     try {
57655       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57656     } catch (std::out_of_range& e) {
57657       {
57658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57659       };
57660     } catch (std::exception& e) {
57661       {
57662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57663       };
57664     } catch (Dali::DaliException e) {
57665       {
57666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57667       };
57668     } catch (...) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57671       };
57672     }
57673   }
57674
57675 }
57676
57677
57678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57679   void * jresult ;
57680   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57681
57682   {
57683     try {
57684       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57685     } catch (std::out_of_range& e) {
57686       {
57687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57688       };
57689     } catch (std::exception& e) {
57690       {
57691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57692       };
57693     } catch (Dali::DaliException e) {
57694       {
57695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57696       };
57697     } catch (...) {
57698       {
57699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57700       };
57701     }
57702   }
57703
57704   jresult = (void *)result;
57705   return jresult;
57706 }
57707
57708
57709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57710   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57711
57712   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57713   {
57714     try {
57715       delete arg1;
57716     } catch (std::out_of_range& e) {
57717       {
57718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57719       };
57720     } catch (std::exception& e) {
57721       {
57722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57723       };
57724     } catch (Dali::DaliException e) {
57725       {
57726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57727       };
57728     } catch (...) {
57729       {
57730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57731       };
57732     }
57733   }
57734
57735 }
57736
57737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57738   unsigned int jresult ;
57739   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57740   bool result;
57741
57742   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57743   {
57744     try {
57745       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57746     } catch (std::out_of_range& e) {
57747       {
57748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57749       };
57750     } catch (std::exception& e) {
57751       {
57752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57753       };
57754     } catch (Dali::DaliException e) {
57755       {
57756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57757       };
57758     } catch (...) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57761       };
57762     }
57763   }
57764
57765   jresult = result;
57766   return jresult;
57767 }
57768
57769
57770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57771   unsigned long jresult ;
57772   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57773   std::size_t result;
57774
57775   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57776   {
57777     try {
57778       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57779     } catch (std::out_of_range& e) {
57780       {
57781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57782       };
57783     } catch (std::exception& e) {
57784       {
57785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57786       };
57787     } catch (Dali::DaliException e) {
57788       {
57789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57790       };
57791     } catch (...) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57794       };
57795     }
57796   }
57797
57798   jresult = (unsigned long)result;
57799   return jresult;
57800 }
57801
57802
57803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57804   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57805   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57806
57807   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57808   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57809   {
57810     try {
57811       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57812     } catch (std::out_of_range& e) {
57813       {
57814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57815       };
57816     } catch (std::exception& e) {
57817       {
57818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57819       };
57820     } catch (Dali::DaliException e) {
57821       {
57822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57823       };
57824     } catch (...) {
57825       {
57826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57827       };
57828     }
57829   }
57830
57831 }
57832
57833
57834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57835   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57836   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57837
57838   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57839   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57840   {
57841     try {
57842       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57843     } catch (std::out_of_range& e) {
57844       {
57845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57846       };
57847     } catch (std::exception& e) {
57848       {
57849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57850       };
57851     } catch (Dali::DaliException e) {
57852       {
57853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57854       };
57855     } catch (...) {
57856       {
57857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57858       };
57859     }
57860   }
57861
57862 }
57863
57864
57865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57866   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57867   Dali::ResourceImage arg2 ;
57868   Dali::ResourceImage *argp2 ;
57869
57870   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57871   argp2 = (Dali::ResourceImage *)jarg2;
57872   if (!argp2) {
57873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57874     return ;
57875   }
57876   arg2 = *argp2;
57877   {
57878     try {
57879       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57880     } catch (std::out_of_range& e) {
57881       {
57882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57883       };
57884     } catch (std::exception& e) {
57885       {
57886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57887       };
57888     } catch (Dali::DaliException e) {
57889       {
57890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57891       };
57892     } catch (...) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57895       };
57896     }
57897   }
57898
57899 }
57900
57901
57902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57903   void * jresult ;
57904   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57905
57906   {
57907     try {
57908       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57909     } catch (std::out_of_range& e) {
57910       {
57911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57912       };
57913     } catch (std::exception& e) {
57914       {
57915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (Dali::DaliException e) {
57918       {
57919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57924       };
57925     }
57926   }
57927
57928   jresult = (void *)result;
57929   return jresult;
57930 }
57931
57932
57933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57934   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57935
57936   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57937   {
57938     try {
57939       delete arg1;
57940     } catch (std::out_of_range& e) {
57941       {
57942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57943       };
57944     } catch (std::exception& e) {
57945       {
57946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57947       };
57948     } catch (Dali::DaliException e) {
57949       {
57950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57951       };
57952     } catch (...) {
57953       {
57954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57955       };
57956     }
57957   }
57958
57959 }
57960
57961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57962   unsigned int jresult ;
57963   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57964   bool result = false;
57965
57966   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57967   {
57968     try {
57969       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);
57970     } catch (std::out_of_range& e) {
57971       {
57972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57973       };
57974     } catch (std::exception& e) {
57975       {
57976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57977       };
57978     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57979   }
57980   jresult = result;
57981   return jresult;
57982 }
57983
57984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57985   unsigned long jresult ;
57986   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57987   std::size_t result = 0;
57988
57989   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57990   {
57991     try {
57992       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);
57993     } catch (std::out_of_range& e) {
57994       {
57995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57996       };
57997     } catch (std::exception& e) {
57998       {
57999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58000       };
58001     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58002   }
58003   jresult = (unsigned long)result;
58004   return jresult;
58005 }
58006
58007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58008   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58009   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58010
58011   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58012   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58013   {
58014     try {
58015       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58016     } catch (std::out_of_range& e) {
58017       {
58018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58019       };
58020     } catch (std::exception& e) {
58021       {
58022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58023       };
58024     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58025   }
58026 }
58027
58028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58029   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58030   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58031
58032   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58033   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58034   {
58035     try {
58036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58037     } catch (std::out_of_range& e) {
58038       {
58039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58040       };
58041     } catch (std::exception& e) {
58042       {
58043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58044       };
58045     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58046   }
58047 }
58048
58049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58050   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58051   Dali::Actor arg2 ;
58052   //bool arg3 ;
58053   Dali::LayoutDirection::Type arg4 ;
58054   Dali::Actor *argp2 ;
58055
58056   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58057   argp2 = (Dali::Actor *)jarg2;
58058   if (!argp2) {
58059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58060     return ;
58061   }
58062   arg2 = *argp2;
58063   //arg3 = jarg3 ? true : false;
58064   arg4 = (Dali::LayoutDirection::Type)jarg4;
58065   {
58066     try {
58067       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58068     } catch (std::out_of_range& e) {
58069       {
58070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58071       };
58072     } catch (std::exception& e) {
58073       {
58074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58075       };
58076     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58077   }
58078 }
58079
58080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58081   void * jresult ;
58082   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58083
58084   {
58085     try {
58086       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58087     } catch (std::out_of_range& e) {
58088       {
58089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58090       };
58091     } catch (std::exception& e) {
58092       {
58093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58094       };
58095     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58096   }
58097   jresult = (void *)result;
58098   return jresult;
58099 }
58100
58101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58102   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58103
58104   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58105   {
58106     try {
58107       delete arg1;
58108     } catch (std::out_of_range& e) {
58109       {
58110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58111       };
58112     } catch (std::exception& e) {
58113       {
58114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58117   }
58118 }
58119
58120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58121   unsigned int jresult ;
58122   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58123   bool result;
58124
58125   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58126   {
58127     try {
58128       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);
58129     } catch (std::out_of_range& e) {
58130       {
58131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58132       };
58133     } catch (std::exception& e) {
58134       {
58135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (Dali::DaliException e) {
58138       {
58139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58140       };
58141     } catch (...) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58144       };
58145     }
58146   }
58147
58148   jresult = result;
58149   return jresult;
58150 }
58151
58152
58153 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58154   unsigned long jresult ;
58155   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58156   std::size_t result;
58157
58158   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58159   {
58160     try {
58161       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);
58162     } catch (std::out_of_range& e) {
58163       {
58164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58165       };
58166     } catch (std::exception& e) {
58167       {
58168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58169       };
58170     } catch (Dali::DaliException e) {
58171       {
58172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58173       };
58174     } catch (...) {
58175       {
58176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58177       };
58178     }
58179   }
58180
58181   jresult = (unsigned long)result;
58182   return jresult;
58183 }
58184
58185
58186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58187   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58188   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58189
58190   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58191   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58192   {
58193     try {
58194       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58195     } catch (std::out_of_range& e) {
58196       {
58197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58198       };
58199     } catch (std::exception& e) {
58200       {
58201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58202       };
58203     } catch (Dali::DaliException e) {
58204       {
58205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58206       };
58207     } catch (...) {
58208       {
58209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58210       };
58211     }
58212   }
58213
58214 }
58215
58216
58217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58218   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58219   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58220
58221   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58222   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58223   {
58224     try {
58225       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58226     } catch (std::out_of_range& e) {
58227       {
58228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58229       };
58230     } catch (std::exception& e) {
58231       {
58232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58233       };
58234     } catch (Dali::DaliException e) {
58235       {
58236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58237       };
58238     } catch (...) {
58239       {
58240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58241       };
58242     }
58243   }
58244
58245 }
58246
58247
58248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58249   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58250   Dali::Actor arg2 ;
58251   bool arg3 ;
58252   Dali::DevelActor::VisibilityChange::Type arg4 ;
58253   Dali::Actor *argp2 ;
58254
58255   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58256   argp2 = (Dali::Actor *)jarg2;
58257   if (!argp2) {
58258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58259     return ;
58260   }
58261   arg2 = *argp2;
58262   arg3 = jarg3 ? true : false;
58263   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58264   {
58265     try {
58266       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58267     } catch (std::out_of_range& e) {
58268       {
58269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58270       };
58271     } catch (std::exception& e) {
58272       {
58273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58274       };
58275     } catch (Dali::DaliException e) {
58276       {
58277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58278       };
58279     } catch (...) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58282       };
58283     }
58284   }
58285
58286 }
58287
58288
58289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58290   void * jresult ;
58291   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58292
58293   {
58294     try {
58295       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58296     } catch (std::out_of_range& e) {
58297       {
58298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58299       };
58300     } catch (std::exception& e) {
58301       {
58302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (Dali::DaliException e) {
58305       {
58306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58307       };
58308     } catch (...) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58311       };
58312     }
58313   }
58314
58315   jresult = (void *)result;
58316   return jresult;
58317 }
58318
58319
58320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58321   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58322
58323   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58324   {
58325     try {
58326       delete arg1;
58327     } catch (std::out_of_range& e) {
58328       {
58329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58330       };
58331     } catch (std::exception& e) {
58332       {
58333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58334       };
58335     } catch (Dali::DaliException e) {
58336       {
58337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58338       };
58339     } catch (...) {
58340       {
58341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58342       };
58343     }
58344   }
58345
58346 }
58347
58348
58349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58350   void * jresult ;
58351   Dali::Timer *result = 0 ;
58352
58353   {
58354     try {
58355       result = (Dali::Timer *)new Dali::Timer();
58356     } catch (std::out_of_range& e) {
58357       {
58358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58359       };
58360     } catch (std::exception& e) {
58361       {
58362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (Dali::DaliException e) {
58365       {
58366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58367       };
58368     } catch (...) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58371       };
58372     }
58373   }
58374
58375   jresult = (void *)result;
58376   return jresult;
58377 }
58378
58379
58380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58381   void * jresult ;
58382   unsigned int arg1 ;
58383   Dali::Timer result;
58384
58385   arg1 = (unsigned int)jarg1;
58386   {
58387     try {
58388       result = Dali::Timer::New(arg1);
58389     } catch (std::out_of_range& e) {
58390       {
58391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58392       };
58393     } catch (std::exception& e) {
58394       {
58395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58396       };
58397     } catch (Dali::DaliException e) {
58398       {
58399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58400       };
58401     } catch (...) {
58402       {
58403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58404       };
58405     }
58406   }
58407
58408   jresult = new Dali::Timer((const Dali::Timer &)result);
58409   return jresult;
58410 }
58411
58412
58413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58414   void * jresult ;
58415   Dali::Timer *arg1 = 0 ;
58416   Dali::Timer *result = 0 ;
58417
58418   arg1 = (Dali::Timer *)jarg1;
58419   if (!arg1) {
58420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58421     return 0;
58422   }
58423   {
58424     try {
58425       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58426     } catch (std::out_of_range& e) {
58427       {
58428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58429       };
58430     } catch (std::exception& e) {
58431       {
58432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (Dali::DaliException e) {
58435       {
58436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58437       };
58438     } catch (...) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58441       };
58442     }
58443   }
58444
58445   jresult = (void *)result;
58446   return jresult;
58447 }
58448
58449
58450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58451   void * jresult ;
58452   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58453   Dali::Timer *arg2 = 0 ;
58454   Dali::Timer *result = 0 ;
58455
58456   arg1 = (Dali::Timer *)jarg1;
58457   arg2 = (Dali::Timer *)jarg2;
58458   if (!arg2) {
58459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58460     return 0;
58461   }
58462   {
58463     try {
58464       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58465     } catch (std::out_of_range& e) {
58466       {
58467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58468       };
58469     } catch (std::exception& e) {
58470       {
58471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58472       };
58473     } catch (Dali::DaliException e) {
58474       {
58475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58476       };
58477     } catch (...) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58480       };
58481     }
58482   }
58483
58484   jresult = (void *)result;
58485   return jresult;
58486 }
58487
58488
58489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58490   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58491
58492   arg1 = (Dali::Timer *)jarg1;
58493   {
58494     try {
58495       delete arg1;
58496     } catch (std::out_of_range& e) {
58497       {
58498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58499       };
58500     } catch (std::exception& e) {
58501       {
58502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58503       };
58504     } catch (Dali::DaliException e) {
58505       {
58506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58507       };
58508     } catch (...) {
58509       {
58510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58511       };
58512     }
58513   }
58514
58515 }
58516
58517
58518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58519   void * jresult ;
58520   Dali::BaseHandle arg1 ;
58521   Dali::BaseHandle *argp1 ;
58522   Dali::Timer result;
58523
58524   argp1 = (Dali::BaseHandle *)jarg1;
58525   if (!argp1) {
58526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58527     return 0;
58528   }
58529   arg1 = *argp1;
58530   {
58531     try {
58532       result = Dali::Timer::DownCast(arg1);
58533     } catch (std::out_of_range& e) {
58534       {
58535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58536       };
58537     } catch (std::exception& e) {
58538       {
58539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58540       };
58541     } catch (Dali::DaliException e) {
58542       {
58543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58544       };
58545     } catch (...) {
58546       {
58547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58548       };
58549     }
58550   }
58551
58552   jresult = new Dali::Timer((const Dali::Timer &)result);
58553   return jresult;
58554 }
58555
58556
58557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58558   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58559
58560   arg1 = (Dali::Timer *)jarg1;
58561   {
58562     try {
58563       (arg1)->Start();
58564     } catch (std::out_of_range& e) {
58565       {
58566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58567       };
58568     } catch (std::exception& e) {
58569       {
58570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58571       };
58572     } catch (Dali::DaliException e) {
58573       {
58574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58575       };
58576     } catch (...) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58579       };
58580     }
58581   }
58582
58583 }
58584
58585
58586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58587   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58588
58589   arg1 = (Dali::Timer *)jarg1;
58590   {
58591     try {
58592       (arg1)->Stop();
58593     } catch (std::out_of_range& e) {
58594       {
58595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58596       };
58597     } catch (std::exception& e) {
58598       {
58599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58600       };
58601     } catch (Dali::DaliException e) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58604       };
58605     } catch (...) {
58606       {
58607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58608       };
58609     }
58610   }
58611
58612 }
58613
58614
58615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58616   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58617   unsigned int arg2 ;
58618
58619   arg1 = (Dali::Timer *)jarg1;
58620   arg2 = (unsigned int)jarg2;
58621   {
58622     try {
58623       (arg1)->SetInterval(arg2);
58624     } catch (std::out_of_range& e) {
58625       {
58626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58627       };
58628     } catch (std::exception& e) {
58629       {
58630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58631       };
58632     } catch (Dali::DaliException e) {
58633       {
58634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58635       };
58636     } catch (...) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58639       };
58640     }
58641   }
58642
58643 }
58644
58645
58646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58647   unsigned int jresult ;
58648   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58649   unsigned int result;
58650
58651   arg1 = (Dali::Timer *)jarg1;
58652   {
58653     try {
58654       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58655     } catch (std::out_of_range& e) {
58656       {
58657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58658       };
58659     } catch (std::exception& e) {
58660       {
58661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (Dali::DaliException e) {
58664       {
58665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58666       };
58667     } catch (...) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58670       };
58671     }
58672   }
58673
58674   jresult = result;
58675   return jresult;
58676 }
58677
58678
58679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58680   unsigned int jresult ;
58681   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58682   bool result;
58683
58684   arg1 = (Dali::Timer *)jarg1;
58685   {
58686     try {
58687       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58688     } catch (std::out_of_range& e) {
58689       {
58690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58691       };
58692     } catch (std::exception& e) {
58693       {
58694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58695       };
58696     } catch (Dali::DaliException e) {
58697       {
58698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58699       };
58700     } catch (...) {
58701       {
58702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58703       };
58704     }
58705   }
58706
58707   jresult = result;
58708   return jresult;
58709 }
58710
58711
58712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58713   void * jresult ;
58714   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58715   Dali::Timer::TimerSignalType *result = 0 ;
58716
58717   arg1 = (Dali::Timer *)jarg1;
58718   {
58719     try {
58720       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58721     } catch (std::out_of_range& e) {
58722       {
58723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (std::exception& e) {
58726       {
58727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (Dali::DaliException e) {
58730       {
58731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58732       };
58733     } catch (...) {
58734       {
58735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58736       };
58737     }
58738   }
58739
58740   jresult = (void *)result;
58741   return jresult;
58742 }
58743
58744
58745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58746   void * jresult ;
58747   Dali::DragAndDropDetector *result = 0 ;
58748
58749   {
58750     try {
58751       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58752     } catch (std::out_of_range& e) {
58753       {
58754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58755       };
58756     } catch (std::exception& e) {
58757       {
58758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58759       };
58760     } catch (Dali::DaliException e) {
58761       {
58762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58763       };
58764     } catch (...) {
58765       {
58766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58767       };
58768     }
58769   }
58770
58771   jresult = (void *)result;
58772   return jresult;
58773 }
58774
58775
58776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58777   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58778
58779   arg1 = (Dali::DragAndDropDetector *)jarg1;
58780   {
58781     try {
58782       delete arg1;
58783     } catch (std::out_of_range& e) {
58784       {
58785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58786       };
58787     } catch (std::exception& e) {
58788       {
58789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58790       };
58791     } catch (Dali::DaliException e) {
58792       {
58793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58794       };
58795     } catch (...) {
58796       {
58797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58798       };
58799     }
58800   }
58801
58802 }
58803
58804
58805 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58806   char * jresult ;
58807   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58808   std::string *result = 0 ;
58809
58810   arg1 = (Dali::DragAndDropDetector *)jarg1;
58811   {
58812     try {
58813       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58814     } catch (std::out_of_range& e) {
58815       {
58816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58817       };
58818     } catch (std::exception& e) {
58819       {
58820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (Dali::DaliException e) {
58823       {
58824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58825       };
58826     } catch (...) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58829       };
58830     }
58831   }
58832
58833   jresult = SWIG_csharp_string_callback(result->c_str());
58834   return jresult;
58835 }
58836
58837
58838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58839   void * jresult ;
58840   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58841   Dali::Vector2 result;
58842
58843   arg1 = (Dali::DragAndDropDetector *)jarg1;
58844   {
58845     try {
58846       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58847     } catch (std::out_of_range& e) {
58848       {
58849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58850       };
58851     } catch (std::exception& e) {
58852       {
58853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58854       };
58855     } catch (Dali::DaliException e) {
58856       {
58857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58858       };
58859     } catch (...) {
58860       {
58861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58862       };
58863     }
58864   }
58865
58866   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58867   return jresult;
58868 }
58869
58870
58871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58872   void * jresult ;
58873   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58874   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58875
58876   arg1 = (Dali::DragAndDropDetector *)jarg1;
58877   {
58878     try {
58879       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58880     } catch (std::out_of_range& e) {
58881       {
58882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58883       };
58884     } catch (std::exception& e) {
58885       {
58886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58887       };
58888     } catch (Dali::DaliException e) {
58889       {
58890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58891       };
58892     } catch (...) {
58893       {
58894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58895       };
58896     }
58897   }
58898
58899   jresult = (void *)result;
58900   return jresult;
58901 }
58902
58903
58904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58905   void * jresult ;
58906   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58907   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58908
58909   arg1 = (Dali::DragAndDropDetector *)jarg1;
58910   {
58911     try {
58912       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58913     } catch (std::out_of_range& e) {
58914       {
58915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58916       };
58917     } catch (std::exception& e) {
58918       {
58919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58920       };
58921     } catch (Dali::DaliException e) {
58922       {
58923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58924       };
58925     } catch (...) {
58926       {
58927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58928       };
58929     }
58930   }
58931
58932   jresult = (void *)result;
58933   return jresult;
58934 }
58935
58936
58937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58938   void * jresult ;
58939   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58940   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58941
58942   arg1 = (Dali::DragAndDropDetector *)jarg1;
58943   {
58944     try {
58945       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58946     } catch (std::out_of_range& e) {
58947       {
58948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58949       };
58950     } catch (std::exception& e) {
58951       {
58952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58953       };
58954     } catch (Dali::DaliException e) {
58955       {
58956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58957       };
58958     } catch (...) {
58959       {
58960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58961       };
58962     }
58963   }
58964
58965   jresult = (void *)result;
58966   return jresult;
58967 }
58968
58969
58970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58971   void * jresult ;
58972   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58973   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58974
58975   arg1 = (Dali::DragAndDropDetector *)jarg1;
58976   {
58977     try {
58978       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58979     } catch (std::out_of_range& e) {
58980       {
58981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58982       };
58983     } catch (std::exception& e) {
58984       {
58985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58986       };
58987     } catch (Dali::DaliException e) {
58988       {
58989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58990       };
58991     } catch (...) {
58992       {
58993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58994       };
58995     }
58996   }
58997
58998   jresult = (void *)result;
58999   return jresult;
59000 }
59001
59002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59003   unsigned int jresult ;
59004   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59005   bool result;
59006
59007   arg1 = (Dali::Signal< bool () > *)jarg1;
59008   {
59009     try {
59010       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59011     } catch (std::out_of_range& e) {
59012       {
59013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59014       };
59015     } catch (std::exception& e) {
59016       {
59017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59018       };
59019     } catch (Dali::DaliException e) {
59020       {
59021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59022       };
59023     } catch (...) {
59024       {
59025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59026       };
59027     }
59028   }
59029
59030   jresult = result;
59031   return jresult;
59032 }
59033
59034
59035 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59036   unsigned long jresult ;
59037   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59038   std::size_t result;
59039
59040   arg1 = (Dali::Signal< bool () > *)jarg1;
59041   {
59042     try {
59043       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59044     } catch (std::out_of_range& e) {
59045       {
59046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59047       };
59048     } catch (std::exception& e) {
59049       {
59050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59051       };
59052     } catch (Dali::DaliException e) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59055       };
59056     } catch (...) {
59057       {
59058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59059       };
59060     }
59061   }
59062
59063   jresult = (unsigned long)result;
59064   return jresult;
59065 }
59066
59067
59068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59069   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59070   bool (*arg2)() = (bool (*)()) 0 ;
59071
59072   arg1 = (Dali::Signal< bool () > *)jarg1;
59073   arg2 = (bool (*)())jarg2;
59074   {
59075     try {
59076       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59077     } catch (std::out_of_range& e) {
59078       {
59079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59080       };
59081     } catch (std::exception& e) {
59082       {
59083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59084       };
59085     } catch (Dali::DaliException e) {
59086       {
59087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59088       };
59089     } catch (...) {
59090       {
59091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59092       };
59093     }
59094   }
59095
59096 }
59097
59098
59099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59100   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59101   bool (*arg2)() = (bool (*)()) 0 ;
59102
59103   arg1 = (Dali::Signal< bool () > *)jarg1;
59104   arg2 = (bool (*)())jarg2;
59105   {
59106     try {
59107       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59108     } catch (std::out_of_range& e) {
59109       {
59110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59111       };
59112     } catch (std::exception& e) {
59113       {
59114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59115       };
59116     } catch (Dali::DaliException e) {
59117       {
59118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59119       };
59120     } catch (...) {
59121       {
59122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59123       };
59124     }
59125   }
59126
59127 }
59128
59129
59130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59131   unsigned int jresult ;
59132   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59133   bool result;
59134
59135   arg1 = (Dali::Signal< bool () > *)jarg1;
59136   {
59137     try {
59138       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59139     } catch (std::out_of_range& e) {
59140       {
59141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59142       };
59143     } catch (std::exception& e) {
59144       {
59145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59146       };
59147     } catch (Dali::DaliException e) {
59148       {
59149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59150       };
59151     } catch (...) {
59152       {
59153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59154       };
59155     }
59156   }
59157
59158   jresult = result;
59159   return jresult;
59160 }
59161
59162
59163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59164   void * jresult ;
59165   Dali::Signal< bool () > *result = 0 ;
59166
59167   {
59168     try {
59169       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59170     } catch (std::out_of_range& e) {
59171       {
59172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59173       };
59174     } catch (std::exception& e) {
59175       {
59176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59177       };
59178     } catch (Dali::DaliException e) {
59179       {
59180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59181       };
59182     } catch (...) {
59183       {
59184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59185       };
59186     }
59187   }
59188
59189   jresult = (void *)result;
59190   return jresult;
59191 }
59192
59193
59194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59195   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59196
59197   arg1 = (Dali::Signal< bool () > *)jarg1;
59198   {
59199     try {
59200       delete arg1;
59201     } catch (std::out_of_range& e) {
59202       {
59203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59204       };
59205     } catch (std::exception& e) {
59206       {
59207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59208       };
59209     } catch (Dali::DaliException e) {
59210       {
59211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59212       };
59213     } catch (...) {
59214       {
59215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59216       };
59217     }
59218   }
59219
59220 }
59221
59222
59223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59224   int jresult ;
59225   int result;
59226
59227   {
59228     try {
59229       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59230     } catch (std::out_of_range& e) {
59231       {
59232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59233       };
59234     } catch (std::exception& e) {
59235       {
59236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59237       };
59238     } catch (Dali::DaliException e) {
59239       {
59240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59241       };
59242     } catch (...) {
59243       {
59244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59245       };
59246     }
59247   }
59248
59249   jresult = (int)result;
59250   return jresult;
59251 }
59252
59253
59254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59255   int jresult ;
59256   int result;
59257
59258   {
59259     try {
59260       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59261     } catch (std::out_of_range& e) {
59262       {
59263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59264       };
59265     } catch (std::exception& e) {
59266       {
59267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59268       };
59269     } catch (Dali::DaliException e) {
59270       {
59271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59272       };
59273     } catch (...) {
59274       {
59275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59276       };
59277     }
59278   }
59279
59280   jresult = (int)result;
59281   return jresult;
59282 }
59283
59284
59285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59286   int jresult ;
59287   int result;
59288
59289   {
59290     try {
59291       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59292     } catch (std::out_of_range& e) {
59293       {
59294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59295       };
59296     } catch (std::exception& e) {
59297       {
59298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59299       };
59300     } catch (Dali::DaliException e) {
59301       {
59302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59303       };
59304     } catch (...) {
59305       {
59306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59307       };
59308     }
59309   }
59310
59311   jresult = (int)result;
59312   return jresult;
59313 }
59314
59315
59316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59317   int jresult ;
59318   int result;
59319
59320   {
59321     try {
59322       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59323     } catch (std::out_of_range& e) {
59324       {
59325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59326       };
59327     } catch (std::exception& e) {
59328       {
59329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59330       };
59331     } catch (Dali::DaliException e) {
59332       {
59333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59334       };
59335     } catch (...) {
59336       {
59337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59338       };
59339     }
59340   }
59341
59342   jresult = (int)result;
59343   return jresult;
59344 }
59345
59346
59347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59348   int jresult ;
59349   int result;
59350
59351   {
59352     try {
59353       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59354     } catch (std::out_of_range& e) {
59355       {
59356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59357       };
59358     } catch (std::exception& e) {
59359       {
59360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59361       };
59362     } catch (Dali::DaliException e) {
59363       {
59364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59365       };
59366     } catch (...) {
59367       {
59368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59369       };
59370     }
59371   }
59372
59373   jresult = (int)result;
59374   return jresult;
59375 }
59376
59377
59378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59379   int jresult ;
59380   int result;
59381
59382   {
59383     try {
59384       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59385     } catch (std::out_of_range& e) {
59386       {
59387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59388       };
59389     } catch (std::exception& e) {
59390       {
59391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59392       };
59393     } catch (Dali::DaliException e) {
59394       {
59395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59396       };
59397     } catch (...) {
59398       {
59399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59400       };
59401     }
59402   }
59403
59404   jresult = (int)result;
59405   return jresult;
59406 }
59407
59408
59409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59410   int jresult ;
59411   int result;
59412
59413   {
59414     try {
59415       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59416     } catch (std::out_of_range& e) {
59417       {
59418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59419       };
59420     } catch (std::exception& e) {
59421       {
59422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59423       };
59424     } catch (Dali::DaliException e) {
59425       {
59426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59427       };
59428     } catch (...) {
59429       {
59430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59431       };
59432     }
59433   }
59434
59435   jresult = (int)result;
59436   return jresult;
59437 }
59438
59439
59440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59441   int jresult ;
59442   int result;
59443
59444   {
59445     try {
59446       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59447     } catch (std::out_of_range& e) {
59448       {
59449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59450       };
59451     } catch (std::exception& e) {
59452       {
59453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59454       };
59455     } catch (Dali::DaliException e) {
59456       {
59457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59458       };
59459     } catch (...) {
59460       {
59461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59462       };
59463     }
59464   }
59465
59466   jresult = (int)result;
59467   return jresult;
59468 }
59469
59470
59471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59472   int jresult ;
59473   int result;
59474
59475   {
59476     try {
59477       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59478     } catch (std::out_of_range& e) {
59479       {
59480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59481       };
59482     } catch (std::exception& e) {
59483       {
59484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59485       };
59486     } catch (Dali::DaliException e) {
59487       {
59488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59489       };
59490     } catch (...) {
59491       {
59492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59493       };
59494     }
59495   }
59496
59497   jresult = (int)result;
59498   return jresult;
59499 }
59500
59501
59502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59503   int jresult ;
59504   int result;
59505
59506   {
59507     try {
59508       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59509     } catch (std::out_of_range& e) {
59510       {
59511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59512       };
59513     } catch (std::exception& e) {
59514       {
59515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59516       };
59517     } catch (Dali::DaliException e) {
59518       {
59519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59520       };
59521     } catch (...) {
59522       {
59523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59524       };
59525     }
59526   }
59527
59528   jresult = (int)result;
59529   return jresult;
59530 }
59531
59532
59533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59534   int jresult ;
59535   int result;
59536
59537   {
59538     try {
59539       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59540     } catch (std::out_of_range& e) {
59541       {
59542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59543       };
59544     } catch (std::exception& e) {
59545       {
59546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59547       };
59548     } catch (Dali::DaliException e) {
59549       {
59550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59551       };
59552     } catch (...) {
59553       {
59554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59555       };
59556     }
59557   }
59558
59559   jresult = (int)result;
59560   return jresult;
59561 }
59562
59563
59564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59565   int jresult ;
59566   int result;
59567
59568   {
59569     try {
59570       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59571     } catch (std::out_of_range& e) {
59572       {
59573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59574       };
59575     } catch (std::exception& e) {
59576       {
59577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59578       };
59579     } catch (Dali::DaliException e) {
59580       {
59581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59582       };
59583     } catch (...) {
59584       {
59585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59586       };
59587     }
59588   }
59589
59590   jresult = (int)result;
59591   return jresult;
59592 }
59593
59594
59595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59596   int jresult ;
59597   int result;
59598
59599   {
59600     try {
59601       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59602     } catch (std::out_of_range& e) {
59603       {
59604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59605       };
59606     } catch (std::exception& e) {
59607       {
59608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59609       };
59610     } catch (Dali::DaliException e) {
59611       {
59612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59613       };
59614     } catch (...) {
59615       {
59616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59617       };
59618     }
59619   }
59620
59621   jresult = (int)result;
59622   return jresult;
59623 }
59624
59625
59626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59627   int jresult ;
59628   int result;
59629
59630   {
59631     try {
59632       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59633     } catch (std::out_of_range& e) {
59634       {
59635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59636       };
59637     } catch (std::exception& e) {
59638       {
59639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59640       };
59641     } catch (Dali::DaliException e) {
59642       {
59643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59644       };
59645     } catch (...) {
59646       {
59647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59648       };
59649     }
59650   }
59651
59652   jresult = (int)result;
59653   return jresult;
59654 }
59655
59656
59657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59658   int jresult ;
59659   int result;
59660
59661   {
59662     try {
59663       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59664     } catch (std::out_of_range& e) {
59665       {
59666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59667       };
59668     } catch (std::exception& e) {
59669       {
59670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59671       };
59672     } catch (Dali::DaliException e) {
59673       {
59674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59675       };
59676     } catch (...) {
59677       {
59678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59679       };
59680     }
59681   }
59682
59683   jresult = (int)result;
59684   return jresult;
59685 }
59686
59687
59688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59689   int jresult ;
59690   int result;
59691
59692   {
59693     try {
59694       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59695     } catch (std::out_of_range& e) {
59696       {
59697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59698       };
59699     } catch (std::exception& e) {
59700       {
59701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59702       };
59703     } catch (Dali::DaliException e) {
59704       {
59705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59706       };
59707     } catch (...) {
59708       {
59709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59710       };
59711     }
59712   }
59713
59714   jresult = (int)result;
59715   return jresult;
59716 }
59717
59718
59719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59720   int jresult ;
59721   int result;
59722
59723   {
59724     try {
59725       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59726     } catch (std::out_of_range& e) {
59727       {
59728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59729       };
59730     } catch (std::exception& e) {
59731       {
59732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59733       };
59734     } catch (Dali::DaliException e) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59737       };
59738     } catch (...) {
59739       {
59740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59741       };
59742     }
59743   }
59744
59745   jresult = (int)result;
59746   return jresult;
59747 }
59748
59749
59750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59751   int jresult ;
59752   int result;
59753
59754   {
59755     try {
59756       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59757     } catch (std::out_of_range& e) {
59758       {
59759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59760       };
59761     } catch (std::exception& e) {
59762       {
59763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59764       };
59765     } catch (Dali::DaliException e) {
59766       {
59767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59768       };
59769     } catch (...) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59772       };
59773     }
59774   }
59775
59776   jresult = (int)result;
59777   return jresult;
59778 }
59779
59780
59781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59782   int jresult ;
59783   int result;
59784
59785   {
59786     try {
59787       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59788     } catch (std::out_of_range& e) {
59789       {
59790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59791       };
59792     } catch (std::exception& e) {
59793       {
59794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59795       };
59796     } catch (Dali::DaliException e) {
59797       {
59798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59799       };
59800     } catch (...) {
59801       {
59802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59803       };
59804     }
59805   }
59806
59807   jresult = (int)result;
59808   return jresult;
59809 }
59810
59811
59812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59813   int jresult ;
59814   int result;
59815
59816   {
59817     try {
59818       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59819     } catch (std::out_of_range& e) {
59820       {
59821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59822       };
59823     } catch (std::exception& e) {
59824       {
59825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59826       };
59827     } catch (Dali::DaliException e) {
59828       {
59829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59830       };
59831     } catch (...) {
59832       {
59833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59834       };
59835     }
59836   }
59837
59838   jresult = (int)result;
59839   return jresult;
59840 }
59841
59842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59843   int jresult ;
59844   int result;
59845
59846   {
59847     try {
59848       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59849     } catch (std::out_of_range& e) {
59850       {
59851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59852       };
59853     } catch (std::exception& e) {
59854       {
59855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59856       };
59857     } catch (Dali::DaliException e) {
59858       {
59859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59860       };
59861     } catch (...) {
59862       {
59863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59864       };
59865     }
59866   }
59867
59868   jresult = (int)result;
59869   return jresult;
59870 }
59871
59872
59873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59874   int jresult ;
59875   int result;
59876   {
59877     try
59878     {
59879       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59880     } catch (std::out_of_range& e) {
59881       {
59882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59883       };
59884     } catch (std::exception& e) {
59885       {
59886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59887       };
59888     } catch (Dali::DaliException e) {
59889       {
59890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59891       };
59892     } catch (...) {
59893       {
59894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59895       };
59896     }
59897   }
59898
59899   jresult = (int)result;
59900   return jresult;
59901 }
59902
59903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59904   int jresult ;
59905   int result;
59906   {
59907     try
59908     {
59909       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59910     } catch (std::out_of_range& e) {
59911       {
59912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59913       };
59914     } catch (std::exception& e) {
59915       {
59916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59917       };
59918     } catch (Dali::DaliException e) {
59919       {
59920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59921       };
59922     } catch (...) {
59923       {
59924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59925       };
59926     }
59927   }
59928
59929   jresult = (int)result;
59930   return jresult;
59931 }
59932
59933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59934   int jresult ;
59935   int result;
59936   {
59937     try
59938     {
59939       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59940     } catch (std::out_of_range& e) {
59941       {
59942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59943       };
59944     } catch (std::exception& e) {
59945       {
59946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59947       };
59948     } catch (Dali::DaliException e) {
59949       {
59950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59951       };
59952     } catch (...) {
59953       {
59954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59955       };
59956     }
59957   }
59958
59959   jresult = (int)result;
59960   return jresult;
59961 }
59962
59963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59964   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59965 }
59966
59967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59968   int jresult ;
59969   int result;
59970   {
59971     try
59972     {
59973       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59974     } catch (std::out_of_range& e) {
59975       {
59976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59977       };
59978     } catch (std::exception& e) {
59979       {
59980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (Dali::DaliException e) {
59983       {
59984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59985       };
59986     } catch (...) {
59987       {
59988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59989       };
59990     }
59991   }
59992
59993   jresult = (int)result;
59994   return jresult;
59995 }
59996
59997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59998   int jresult ;
59999   int result;
60000   {
60001     try
60002     {
60003       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60004     } catch (std::out_of_range& e) {
60005       {
60006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (std::exception& e) {
60009       {
60010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60011       };
60012     } catch (Dali::DaliException e) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60015       };
60016     } catch (...) {
60017       {
60018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60019       };
60020     }
60021   }
60022
60023   jresult = (int)result;
60024   return jresult;
60025 }
60026
60027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60028   int jresult ;
60029   int result;
60030
60031   {
60032     try {
60033       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60034     } catch (std::out_of_range& e) {
60035       {
60036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60037       };
60038     } catch (std::exception& e) {
60039       {
60040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60041       };
60042     } catch (Dali::DaliException e) {
60043       {
60044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60045       };
60046     } catch (...) {
60047       {
60048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60049       };
60050     }
60051   }
60052
60053   jresult = (int)result;
60054   return jresult;
60055 }
60056
60057
60058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60059   int jresult ;
60060   int result;
60061
60062   {
60063     try {
60064       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60065     } catch (std::out_of_range& e) {
60066       {
60067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60068       };
60069     } catch (std::exception& e) {
60070       {
60071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60072       };
60073     } catch (Dali::DaliException e) {
60074       {
60075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60076       };
60077     } catch (...) {
60078       {
60079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60080       };
60081     }
60082   }
60083
60084   jresult = (int)result;
60085   return jresult;
60086 }
60087
60088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60089   int jresult ;
60090   int result;
60091   {
60092     try
60093     {
60094       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60095     } catch (std::out_of_range& e) {
60096       {
60097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60098       };
60099     } catch (std::exception& e) {
60100       {
60101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60102       };
60103     } catch (...) {
60104       {
60105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60106       };
60107     }
60108   }
60109   jresult = (int)result;
60110   return jresult;
60111 }
60112
60113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60114   int jresult ;
60115   int result;
60116   {
60117     try
60118     {
60119       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60120     } catch (std::out_of_range& e) {
60121       {
60122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60123       };
60124     } catch (std::exception& e) {
60125       {
60126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (...) {
60129       {
60130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60131       };
60132     }
60133   }
60134   jresult = (int)result;
60135   return jresult;
60136 }
60137
60138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60139   int jresult ;
60140   int result;
60141   {
60142     try
60143     {
60144       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60145     } catch (std::out_of_range& e) {
60146       {
60147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (std::exception& e) {
60150       {
60151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60152       };
60153     } catch (...) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60156       };
60157     }
60158   }
60159   jresult = (int)result;
60160   return jresult;
60161 }
60162
60163
60164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60165   int jresult ;
60166   int result;
60167   {
60168     try
60169     {
60170       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60171     } catch (std::out_of_range& e) {
60172       {
60173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60174       };
60175     } catch (std::exception& e) {
60176       {
60177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60178       };
60179     } catch (...) {
60180       {
60181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60182       };
60183     }
60184   }
60185   jresult = (int)result;
60186   return jresult;
60187 }
60188
60189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60190   int jresult ;
60191   int result;
60192   {
60193     try
60194     {
60195       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60196     } catch (std::out_of_range& e) {
60197       {
60198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60199       };
60200     } catch (std::exception& e) {
60201       {
60202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60203       };
60204     } catch (...) {
60205       {
60206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60207       };
60208     }
60209   }
60210   jresult = (int)result;
60211   return jresult;
60212 }
60213
60214
60215
60216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60217   int jresult ;
60218   int result;
60219
60220   {
60221     try {
60222       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60223     } catch (std::out_of_range& e) {
60224       {
60225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60226       };
60227     } catch (std::exception& e) {
60228       {
60229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60230       };
60231     } catch (Dali::DaliException e) {
60232       {
60233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60234       };
60235     } catch (...) {
60236       {
60237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60238       };
60239     }
60240   }
60241
60242   jresult = (int)result;
60243   return jresult;
60244 }
60245
60246
60247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60248   int jresult ;
60249   int result;
60250
60251   {
60252     try {
60253       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60254     } catch (std::out_of_range& e) {
60255       {
60256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60257       };
60258     } catch (std::exception& e) {
60259       {
60260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60261       };
60262     } catch (Dali::DaliException e) {
60263       {
60264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60265       };
60266     } catch (...) {
60267       {
60268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60269       };
60270     }
60271   }
60272
60273   jresult = (int)result;
60274   return jresult;
60275 }
60276
60277
60278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60279   int jresult ;
60280   int result;
60281
60282   {
60283     try {
60284       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60285     } catch (std::out_of_range& e) {
60286       {
60287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60288       };
60289     } catch (std::exception& e) {
60290       {
60291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60292       };
60293     } catch (Dali::DaliException e) {
60294       {
60295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60296       };
60297     } catch (...) {
60298       {
60299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60300       };
60301     }
60302   }
60303
60304   jresult = (int)result;
60305   return jresult;
60306 }
60307
60308
60309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60310   int jresult ;
60311   int result;
60312
60313   {
60314     try {
60315       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60316     } catch (std::out_of_range& e) {
60317       {
60318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60319       };
60320     } catch (std::exception& e) {
60321       {
60322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60323       };
60324     } catch (Dali::DaliException e) {
60325       {
60326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60327       };
60328     } catch (...) {
60329       {
60330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60331       };
60332     }
60333   }
60334
60335   jresult = (int)result;
60336   return jresult;
60337 }
60338
60339
60340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60341   int jresult ;
60342   int result;
60343
60344   {
60345     try {
60346       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60347     } catch (std::out_of_range& e) {
60348       {
60349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60350       };
60351     } catch (std::exception& e) {
60352       {
60353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60354       };
60355     } catch (Dali::DaliException e) {
60356       {
60357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60358       };
60359     } catch (...) {
60360       {
60361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60362       };
60363     }
60364   }
60365
60366   jresult = (int)result;
60367   return jresult;
60368 }
60369
60370
60371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60372   int jresult ;
60373   int result;
60374
60375   {
60376     try {
60377       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60378     } catch (std::out_of_range& e) {
60379       {
60380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60381       };
60382     } catch (std::exception& e) {
60383       {
60384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60385       };
60386     } catch (Dali::DaliException e) {
60387       {
60388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60389       };
60390     } catch (...) {
60391       {
60392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60393       };
60394     }
60395   }
60396
60397   jresult = (int)result;
60398   return jresult;
60399 }
60400
60401
60402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60403   int jresult ;
60404   int result;
60405
60406   {
60407     try {
60408       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60409     } catch (std::out_of_range& e) {
60410       {
60411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60412       };
60413     } catch (std::exception& e) {
60414       {
60415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60416       };
60417     } catch (Dali::DaliException e) {
60418       {
60419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60420       };
60421     } catch (...) {
60422       {
60423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60424       };
60425     }
60426   }
60427
60428   jresult = (int)result;
60429   return jresult;
60430 }
60431
60432 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60433   int jresult ;
60434   int result;
60435
60436   {
60437     try {
60438       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60439     } catch (std::out_of_range& e) {
60440       {
60441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60442       };
60443     } catch (std::exception& e) {
60444       {
60445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60446       };
60447     } catch (...) {
60448       {
60449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60450       };
60451     }
60452   }
60453   jresult = (int)result;
60454   return jresult;
60455 }
60456
60457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60458   int jresult ;
60459   int result;
60460
60461   {
60462     try {
60463       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60464     } catch (std::out_of_range& e) {
60465       {
60466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60467       };
60468     } catch (std::exception& e) {
60469       {
60470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60471       };
60472     } catch (Dali::DaliException e) {
60473       {
60474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60475       };
60476     } catch (...) {
60477       {
60478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60479       };
60480     }
60481   }
60482
60483   jresult = (int)result;
60484   return jresult;
60485 }
60486
60487
60488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60489   int jresult ;
60490   int result;
60491
60492   {
60493     try {
60494       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60495     } catch (std::out_of_range& e) {
60496       {
60497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60498       };
60499     } catch (std::exception& e) {
60500       {
60501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60502       };
60503     } catch (Dali::DaliException e) {
60504       {
60505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60506       };
60507     } catch (...) {
60508       {
60509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60510       };
60511     }
60512   }
60513
60514   jresult = (int)result;
60515   return jresult;
60516 }
60517
60518
60519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60520   int jresult ;
60521   int result;
60522
60523   {
60524     try {
60525       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60526     } catch (std::out_of_range& e) {
60527       {
60528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60529       };
60530     } catch (std::exception& e) {
60531       {
60532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60533       };
60534     } catch (Dali::DaliException e) {
60535       {
60536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60537       };
60538     } catch (...) {
60539       {
60540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60541       };
60542     }
60543   }
60544
60545   jresult = (int)result;
60546   return jresult;
60547 }
60548
60549
60550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60551   int jresult ;
60552   int result;
60553
60554   {
60555     try {
60556       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60557     } catch (std::out_of_range& e) {
60558       {
60559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60560       };
60561     } catch (std::exception& e) {
60562       {
60563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60564       };
60565     } catch (Dali::DaliException e) {
60566       {
60567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60568       };
60569     } catch (...) {
60570       {
60571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60572       };
60573     }
60574   }
60575
60576   jresult = (int)result;
60577   return jresult;
60578 }
60579
60580
60581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60582   int jresult ;
60583   int result;
60584
60585   {
60586     try {
60587       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60588     } catch (std::out_of_range& e) {
60589       {
60590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60591       };
60592     } catch (std::exception& e) {
60593       {
60594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60595       };
60596     } catch (Dali::DaliException e) {
60597       {
60598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60599       };
60600     } catch (...) {
60601       {
60602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60603       };
60604     }
60605   }
60606
60607   jresult = (int)result;
60608   return jresult;
60609 }
60610
60611
60612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60613   int jresult ;
60614   int result;
60615
60616   {
60617     try {
60618       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60619     } catch (std::out_of_range& e) {
60620       {
60621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (std::exception& e) {
60624       {
60625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60626       };
60627     } catch (Dali::DaliException e) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60630       };
60631     } catch (...) {
60632       {
60633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60634       };
60635     }
60636   }
60637
60638   jresult = (int)result;
60639   return jresult;
60640 }
60641
60642
60643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60644   int jresult ;
60645   int result;
60646
60647   {
60648     try {
60649       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60650     } catch (std::out_of_range& e) {
60651       {
60652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60653       };
60654     } catch (std::exception& e) {
60655       {
60656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60657       };
60658     } catch (Dali::DaliException e) {
60659       {
60660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60661       };
60662     } catch (...) {
60663       {
60664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60665       };
60666     }
60667   }
60668
60669   jresult = (int)result;
60670   return jresult;
60671 }
60672
60673
60674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60675   int jresult ;
60676   int result;
60677
60678   {
60679     try {
60680       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60681     } catch (std::out_of_range& e) {
60682       {
60683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60684       };
60685     } catch (std::exception& e) {
60686       {
60687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60688       };
60689     } catch (Dali::DaliException e) {
60690       {
60691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60692       };
60693     } catch (...) {
60694       {
60695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60696       };
60697     }
60698   }
60699
60700   jresult = (int)result;
60701   return jresult;
60702 }
60703
60704
60705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60706   int jresult ;
60707   int result;
60708
60709   {
60710     try {
60711       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60712     } catch (std::out_of_range& e) {
60713       {
60714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60715       };
60716     } catch (std::exception& e) {
60717       {
60718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60719       };
60720     } catch (Dali::DaliException e) {
60721       {
60722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60723       };
60724     } catch (...) {
60725       {
60726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60727       };
60728     }
60729   }
60730
60731   jresult = (int)result;
60732   return jresult;
60733 }
60734
60735
60736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60737   int jresult ;
60738   int result;
60739
60740   {
60741     try {
60742       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60743     } catch (std::out_of_range& e) {
60744       {
60745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60746       };
60747     } catch (std::exception& e) {
60748       {
60749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60750       };
60751     } catch (Dali::DaliException e) {
60752       {
60753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60754       };
60755     } catch (...) {
60756       {
60757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60758       };
60759     }
60760   }
60761
60762   jresult = (int)result;
60763   return jresult;
60764 }
60765
60766
60767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60768   int jresult ;
60769   int result;
60770
60771   {
60772     try {
60773       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60774     } catch (std::out_of_range& e) {
60775       {
60776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60777       };
60778     } catch (std::exception& e) {
60779       {
60780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60781       };
60782     } catch (Dali::DaliException e) {
60783       {
60784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60785       };
60786     } catch (...) {
60787       {
60788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60789       };
60790     }
60791   }
60792
60793   jresult = (int)result;
60794   return jresult;
60795 }
60796
60797
60798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60799   int jresult ;
60800   int result;
60801
60802   {
60803     try {
60804       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60805     } catch (std::out_of_range& e) {
60806       {
60807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60808       };
60809     } catch (std::exception& e) {
60810       {
60811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60812       };
60813     } catch (Dali::DaliException e) {
60814       {
60815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60816       };
60817     } catch (...) {
60818       {
60819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60820       };
60821     }
60822   }
60823
60824   jresult = (int)result;
60825   return jresult;
60826 }
60827
60828
60829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60830   int jresult ;
60831   int result;
60832
60833   {
60834     try {
60835       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60836     } catch (std::out_of_range& e) {
60837       {
60838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60839       };
60840     } catch (std::exception& e) {
60841       {
60842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60843       };
60844     } catch (Dali::DaliException e) {
60845       {
60846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60847       };
60848     } catch (...) {
60849       {
60850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60851       };
60852     }
60853   }
60854
60855   jresult = (int)result;
60856   return jresult;
60857 }
60858
60859
60860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60861   int jresult ;
60862   int result;
60863
60864   {
60865     try {
60866       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60867     } catch (std::out_of_range& e) {
60868       {
60869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60870       };
60871     } catch (std::exception& e) {
60872       {
60873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60874       };
60875     } catch (Dali::DaliException e) {
60876       {
60877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60878       };
60879     } catch (...) {
60880       {
60881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60882       };
60883     }
60884   }
60885
60886   jresult = (int)result;
60887   return jresult;
60888 }
60889
60890
60891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60892   int jresult ;
60893   int result;
60894
60895   {
60896     try {
60897       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60898     } catch (std::out_of_range& e) {
60899       {
60900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60901       };
60902     } catch (std::exception& e) {
60903       {
60904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60905       };
60906     } catch (Dali::DaliException e) {
60907       {
60908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60909       };
60910     } catch (...) {
60911       {
60912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60913       };
60914     }
60915   }
60916
60917   jresult = (int)result;
60918   return jresult;
60919 }
60920
60921
60922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60923   int jresult ;
60924   int result;
60925
60926   {
60927     try {
60928       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60929     } catch (std::out_of_range& e) {
60930       {
60931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60932       };
60933     } catch (std::exception& e) {
60934       {
60935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60936       };
60937     } catch (Dali::DaliException e) {
60938       {
60939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60940       };
60941     } catch (...) {
60942       {
60943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60944       };
60945     }
60946   }
60947
60948   jresult = (int)result;
60949   return jresult;
60950 }
60951
60952
60953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60954   int jresult ;
60955   int result;
60956
60957   {
60958     try {
60959       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60960     } catch (std::out_of_range& e) {
60961       {
60962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60963       };
60964     } catch (std::exception& e) {
60965       {
60966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60967       };
60968     } catch (Dali::DaliException e) {
60969       {
60970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60971       };
60972     } catch (...) {
60973       {
60974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60975       };
60976     }
60977   }
60978
60979   jresult = (int)result;
60980   return jresult;
60981 }
60982
60983
60984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60985   int jresult ;
60986   int result;
60987
60988   {
60989     try {
60990       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60991     } catch (std::out_of_range& e) {
60992       {
60993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60994       };
60995     } catch (std::exception& e) {
60996       {
60997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60998       };
60999     } catch (Dali::DaliException e) {
61000       {
61001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61002       };
61003     } catch (...) {
61004       {
61005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61006       };
61007     }
61008   }
61009
61010   jresult = (int)result;
61011   return jresult;
61012 }
61013
61014
61015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61016   int jresult ;
61017   int result;
61018
61019   {
61020     try {
61021       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61022     } catch (std::out_of_range& e) {
61023       {
61024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61025       };
61026     } catch (std::exception& e) {
61027       {
61028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61029       };
61030     } catch (Dali::DaliException e) {
61031       {
61032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61033       };
61034     } catch (...) {
61035       {
61036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61037       };
61038     }
61039   }
61040
61041   jresult = (int)result;
61042   return jresult;
61043 }
61044
61045
61046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61047   int jresult ;
61048   int result;
61049
61050   {
61051     try {
61052       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61053     } catch (std::out_of_range& e) {
61054       {
61055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61056       };
61057     } catch (std::exception& e) {
61058       {
61059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61060       };
61061     } catch (Dali::DaliException e) {
61062       {
61063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61064       };
61065     } catch (...) {
61066       {
61067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61068       };
61069     }
61070   }
61071
61072   jresult = (int)result;
61073   return jresult;
61074 }
61075
61076
61077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61078   int jresult ;
61079   int result;
61080
61081   {
61082     try {
61083       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61084     } catch (std::out_of_range& e) {
61085       {
61086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61087       };
61088     } catch (std::exception& e) {
61089       {
61090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61091       };
61092     } catch (Dali::DaliException e) {
61093       {
61094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61095       };
61096     } catch (...) {
61097       {
61098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61099       };
61100     }
61101   }
61102
61103   jresult = (int)result;
61104   return jresult;
61105 }
61106
61107
61108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61109   int jresult ;
61110   int result;
61111
61112   {
61113     try {
61114       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61115     } catch (std::out_of_range& e) {
61116       {
61117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61118       };
61119     } catch (std::exception& e) {
61120       {
61121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61122       };
61123     } catch (Dali::DaliException e) {
61124       {
61125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61126       };
61127     } catch (...) {
61128       {
61129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61130       };
61131     }
61132   }
61133
61134   jresult = (int)result;
61135   return jresult;
61136 }
61137
61138
61139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61140   int jresult ;
61141   int result;
61142
61143   {
61144     try {
61145       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61146     } catch (std::out_of_range& e) {
61147       {
61148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61149       };
61150     } catch (std::exception& e) {
61151       {
61152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61153       };
61154     } catch (Dali::DaliException e) {
61155       {
61156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61157       };
61158     } catch (...) {
61159       {
61160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61161       };
61162     }
61163   }
61164
61165   jresult = (int)result;
61166   return jresult;
61167 }
61168
61169
61170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61171   int jresult ;
61172   int result;
61173
61174   {
61175     try {
61176       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61177     } catch (std::out_of_range& e) {
61178       {
61179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61180       };
61181     } catch (std::exception& e) {
61182       {
61183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61184       };
61185     } catch (Dali::DaliException e) {
61186       {
61187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61188       };
61189     } catch (...) {
61190       {
61191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61192       };
61193     }
61194   }
61195
61196   jresult = (int)result;
61197   return jresult;
61198 }
61199
61200
61201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61202   int jresult ;
61203   int result;
61204
61205   {
61206     try {
61207       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61208     } catch (std::out_of_range& e) {
61209       {
61210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61211       };
61212     } catch (std::exception& e) {
61213       {
61214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61215       };
61216     } catch (Dali::DaliException e) {
61217       {
61218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61219       };
61220     } catch (...) {
61221       {
61222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61223       };
61224     }
61225   }
61226
61227   jresult = (int)result;
61228   return jresult;
61229 }
61230
61231
61232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61233   int jresult ;
61234   int result;
61235
61236   {
61237     try {
61238       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61239     } catch (std::out_of_range& e) {
61240       {
61241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61242       };
61243     } catch (std::exception& e) {
61244       {
61245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61246       };
61247     } catch (Dali::DaliException e) {
61248       {
61249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61250       };
61251     } catch (...) {
61252       {
61253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61254       };
61255     }
61256   }
61257
61258   jresult = (int)result;
61259   return jresult;
61260 }
61261
61262
61263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61264   int jresult ;
61265   int result;
61266
61267   {
61268     try {
61269       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61270     } catch (std::out_of_range& e) {
61271       {
61272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61273       };
61274     } catch (std::exception& e) {
61275       {
61276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61277       };
61278     } catch (Dali::DaliException e) {
61279       {
61280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61281       };
61282     } catch (...) {
61283       {
61284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61285       };
61286     }
61287   }
61288
61289   jresult = (int)result;
61290   return jresult;
61291 }
61292
61293
61294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61295   int jresult ;
61296   int result;
61297
61298   {
61299     try {
61300       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61301     } catch (std::out_of_range& e) {
61302       {
61303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61304       };
61305     } catch (std::exception& e) {
61306       {
61307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61308       };
61309     } catch (Dali::DaliException e) {
61310       {
61311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61312       };
61313     } catch (...) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61316       };
61317     }
61318   }
61319
61320   jresult = (int)result;
61321   return jresult;
61322 }
61323
61324
61325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61326   void * jresult ;
61327   Dali::Toolkit::Builder *result = 0 ;
61328
61329   {
61330     try {
61331       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61332     } catch (std::out_of_range& e) {
61333       {
61334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61335       };
61336     } catch (std::exception& e) {
61337       {
61338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61339       };
61340     } catch (Dali::DaliException e) {
61341       {
61342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61343       };
61344     } catch (...) {
61345       {
61346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61347       };
61348     }
61349   }
61350
61351   jresult = (void *)result;
61352   return jresult;
61353 }
61354
61355
61356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61357   void * jresult ;
61358   Dali::Toolkit::Builder result;
61359
61360   {
61361     try {
61362       result = Dali::Toolkit::Builder::New();
61363     } catch (std::out_of_range& e) {
61364       {
61365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61366       };
61367     } catch (std::exception& e) {
61368       {
61369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61370       };
61371     } catch (Dali::DaliException e) {
61372       {
61373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61374       };
61375     } catch (...) {
61376       {
61377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61378       };
61379     }
61380   }
61381
61382   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61383   return jresult;
61384 }
61385
61386
61387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61388   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61389
61390   arg1 = (Dali::Toolkit::Builder *)jarg1;
61391   {
61392     try {
61393       delete arg1;
61394     } catch (std::out_of_range& e) {
61395       {
61396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61397       };
61398     } catch (std::exception& e) {
61399       {
61400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61401       };
61402     } catch (Dali::DaliException e) {
61403       {
61404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61405       };
61406     } catch (...) {
61407       {
61408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61409       };
61410     }
61411   }
61412
61413 }
61414
61415
61416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61418   std::string *arg2 = 0 ;
61419   Dali::Toolkit::Builder::UIFormat arg3 ;
61420
61421   arg1 = (Dali::Toolkit::Builder *)jarg1;
61422   if (!jarg2) {
61423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61424     return ;
61425   }
61426   std::string arg2_str(jarg2);
61427   arg2 = &arg2_str;
61428   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61429   {
61430     try {
61431       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61432     } catch (std::out_of_range& e) {
61433       {
61434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61435       };
61436     } catch (std::exception& e) {
61437       {
61438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61439       };
61440     } catch (Dali::DaliException e) {
61441       {
61442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61443       };
61444     } catch (...) {
61445       {
61446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61447       };
61448     }
61449   }
61450
61451
61452   //argout typemap for const std::string&
61453
61454 }
61455
61456
61457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61458   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61459   std::string *arg2 = 0 ;
61460
61461   arg1 = (Dali::Toolkit::Builder *)jarg1;
61462   if (!jarg2) {
61463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61464     return ;
61465   }
61466   std::string arg2_str(jarg2);
61467   arg2 = &arg2_str;
61468   {
61469     try {
61470       (arg1)->LoadFromString((std::string const &)*arg2);
61471     } catch (std::out_of_range& e) {
61472       {
61473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61474       };
61475     } catch (std::exception& e) {
61476       {
61477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61478       };
61479     } catch (Dali::DaliException e) {
61480       {
61481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61482       };
61483     } catch (...) {
61484       {
61485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61486       };
61487     }
61488   }
61489
61490
61491   //argout typemap for const std::string&
61492
61493 }
61494
61495
61496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61497   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61498   Dali::Property::Map *arg2 = 0 ;
61499
61500   arg1 = (Dali::Toolkit::Builder *)jarg1;
61501   arg2 = (Dali::Property::Map *)jarg2;
61502   if (!arg2) {
61503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61504     return ;
61505   }
61506   {
61507     try {
61508       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61509     } catch (std::out_of_range& e) {
61510       {
61511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61512       };
61513     } catch (std::exception& e) {
61514       {
61515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61516       };
61517     } catch (Dali::DaliException e) {
61518       {
61519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61520       };
61521     } catch (...) {
61522       {
61523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61524       };
61525     }
61526   }
61527
61528 }
61529
61530
61531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61532   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61533   std::string *arg2 = 0 ;
61534   Dali::Property::Value *arg3 = 0 ;
61535
61536   arg1 = (Dali::Toolkit::Builder *)jarg1;
61537   if (!jarg2) {
61538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61539     return ;
61540   }
61541   std::string arg2_str(jarg2);
61542   arg2 = &arg2_str;
61543   arg3 = (Dali::Property::Value *)jarg3;
61544   if (!arg3) {
61545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61546     return ;
61547   }
61548   {
61549     try {
61550       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61551     } catch (std::out_of_range& e) {
61552       {
61553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61554       };
61555     } catch (std::exception& e) {
61556       {
61557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61558       };
61559     } catch (Dali::DaliException e) {
61560       {
61561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61562       };
61563     } catch (...) {
61564       {
61565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61566       };
61567     }
61568   }
61569
61570
61571   //argout typemap for const std::string&
61572
61573 }
61574
61575
61576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61577   void * jresult ;
61578   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61579   Dali::Property::Map *result = 0 ;
61580
61581   arg1 = (Dali::Toolkit::Builder *)jarg1;
61582   {
61583     try {
61584       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61585     } catch (std::out_of_range& e) {
61586       {
61587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61588       };
61589     } catch (std::exception& e) {
61590       {
61591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61592       };
61593     } catch (Dali::DaliException e) {
61594       {
61595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61596       };
61597     } catch (...) {
61598       {
61599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61600       };
61601     }
61602   }
61603
61604   jresult = (void *)result;
61605   return jresult;
61606 }
61607
61608
61609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61610   void * jresult ;
61611   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61612   std::string *arg2 = 0 ;
61613   Dali::Property::Value *result = 0 ;
61614
61615   arg1 = (Dali::Toolkit::Builder *)jarg1;
61616   if (!jarg2) {
61617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61618     return 0;
61619   }
61620   std::string arg2_str(jarg2);
61621   arg2 = &arg2_str;
61622   {
61623     try {
61624       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
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 = (void *)result;
61645
61646   //argout typemap for const std::string&
61647
61648   return jresult;
61649 }
61650
61651
61652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61653   void * jresult ;
61654   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61655   std::string *arg2 = 0 ;
61656   Dali::Animation result;
61657
61658   arg1 = (Dali::Toolkit::Builder *)jarg1;
61659   if (!jarg2) {
61660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61661     return 0;
61662   }
61663   std::string arg2_str(jarg2);
61664   arg2 = &arg2_str;
61665   {
61666     try {
61667       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61668     } catch (std::out_of_range& e) {
61669       {
61670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (std::exception& e) {
61673       {
61674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61675       };
61676     } catch (Dali::DaliException e) {
61677       {
61678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61679       };
61680     } catch (...) {
61681       {
61682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61683       };
61684     }
61685   }
61686
61687   jresult = new Dali::Animation((const Dali::Animation &)result);
61688
61689   //argout typemap for const std::string&
61690
61691   return jresult;
61692 }
61693
61694
61695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61696   void * jresult ;
61697   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61698   std::string *arg2 = 0 ;
61699   Dali::Property::Map *arg3 = 0 ;
61700   Dali::Animation result;
61701
61702   arg1 = (Dali::Toolkit::Builder *)jarg1;
61703   if (!jarg2) {
61704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61705     return 0;
61706   }
61707   std::string arg2_str(jarg2);
61708   arg2 = &arg2_str;
61709   arg3 = (Dali::Property::Map *)jarg3;
61710   if (!arg3) {
61711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61712     return 0;
61713   }
61714   {
61715     try {
61716       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61717     } catch (std::out_of_range& e) {
61718       {
61719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61720       };
61721     } catch (std::exception& e) {
61722       {
61723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61724       };
61725     } catch (Dali::DaliException e) {
61726       {
61727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61728       };
61729     } catch (...) {
61730       {
61731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61732       };
61733     }
61734   }
61735
61736   jresult = new Dali::Animation((const Dali::Animation &)result);
61737
61738   //argout typemap for const std::string&
61739
61740   return jresult;
61741 }
61742
61743
61744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61745   void * jresult ;
61746   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61747   std::string *arg2 = 0 ;
61748   Dali::Actor arg3 ;
61749   Dali::Actor *argp3 ;
61750   Dali::Animation result;
61751
61752   arg1 = (Dali::Toolkit::Builder *)jarg1;
61753   if (!jarg2) {
61754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61755     return 0;
61756   }
61757   std::string arg2_str(jarg2);
61758   arg2 = &arg2_str;
61759   argp3 = (Dali::Actor *)jarg3;
61760   if (!argp3) {
61761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61762     return 0;
61763   }
61764   arg3 = *argp3;
61765   {
61766     try {
61767       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61768     } catch (std::out_of_range& e) {
61769       {
61770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61771       };
61772     } catch (std::exception& e) {
61773       {
61774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61775       };
61776     } catch (Dali::DaliException e) {
61777       {
61778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61779       };
61780     } catch (...) {
61781       {
61782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61783       };
61784     }
61785   }
61786
61787   jresult = new Dali::Animation((const Dali::Animation &)result);
61788
61789   //argout typemap for const std::string&
61790
61791   return jresult;
61792 }
61793
61794
61795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61796   void * jresult ;
61797   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61798   std::string *arg2 = 0 ;
61799   Dali::Property::Map *arg3 = 0 ;
61800   Dali::Actor arg4 ;
61801   Dali::Actor *argp4 ;
61802   Dali::Animation result;
61803
61804   arg1 = (Dali::Toolkit::Builder *)jarg1;
61805   if (!jarg2) {
61806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61807     return 0;
61808   }
61809   std::string arg2_str(jarg2);
61810   arg2 = &arg2_str;
61811   arg3 = (Dali::Property::Map *)jarg3;
61812   if (!arg3) {
61813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61814     return 0;
61815   }
61816   argp4 = (Dali::Actor *)jarg4;
61817   if (!argp4) {
61818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61819     return 0;
61820   }
61821   arg4 = *argp4;
61822   {
61823     try {
61824       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61825     } catch (std::out_of_range& e) {
61826       {
61827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61828       };
61829     } catch (std::exception& e) {
61830       {
61831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61832       };
61833     } catch (Dali::DaliException e) {
61834       {
61835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61836       };
61837     } catch (...) {
61838       {
61839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61840       };
61841     }
61842   }
61843
61844   jresult = new Dali::Animation((const Dali::Animation &)result);
61845
61846   //argout typemap for const std::string&
61847
61848   return jresult;
61849 }
61850
61851
61852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61853   void * jresult ;
61854   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61855   std::string *arg2 = 0 ;
61856   Dali::BaseHandle result;
61857
61858   arg1 = (Dali::Toolkit::Builder *)jarg1;
61859   if (!jarg2) {
61860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61861     return 0;
61862   }
61863   std::string arg2_str(jarg2);
61864   arg2 = &arg2_str;
61865   {
61866     try {
61867       result = (arg1)->Create((std::string const &)*arg2);
61868     } catch (std::out_of_range& e) {
61869       {
61870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61871       };
61872     } catch (std::exception& e) {
61873       {
61874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61875       };
61876     } catch (Dali::DaliException e) {
61877       {
61878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61879       };
61880     } catch (...) {
61881       {
61882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61883       };
61884     }
61885   }
61886
61887   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61888
61889   //argout typemap for const std::string&
61890
61891   return jresult;
61892 }
61893
61894
61895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61896   void * jresult ;
61897   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61898   std::string *arg2 = 0 ;
61899   Dali::Property::Map *arg3 = 0 ;
61900   Dali::BaseHandle result;
61901
61902   arg1 = (Dali::Toolkit::Builder *)jarg1;
61903   if (!jarg2) {
61904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61905     return 0;
61906   }
61907   std::string arg2_str(jarg2);
61908   arg2 = &arg2_str;
61909   arg3 = (Dali::Property::Map *)jarg3;
61910   if (!arg3) {
61911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61912     return 0;
61913   }
61914   {
61915     try {
61916       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61917     } catch (std::out_of_range& e) {
61918       {
61919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61920       };
61921     } catch (std::exception& e) {
61922       {
61923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61924       };
61925     } catch (Dali::DaliException e) {
61926       {
61927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61928       };
61929     } catch (...) {
61930       {
61931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61932       };
61933     }
61934   }
61935
61936   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61937
61938   //argout typemap for const std::string&
61939
61940   return jresult;
61941 }
61942
61943
61944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61945   void * jresult ;
61946   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61947   std::string *arg2 = 0 ;
61948   Dali::BaseHandle result;
61949
61950   arg1 = (Dali::Toolkit::Builder *)jarg1;
61951   if (!jarg2) {
61952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61953     return 0;
61954   }
61955   std::string arg2_str(jarg2);
61956   arg2 = &arg2_str;
61957   {
61958     try {
61959       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61960     } catch (std::out_of_range& e) {
61961       {
61962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61963       };
61964     } catch (std::exception& e) {
61965       {
61966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61967       };
61968     } catch (Dali::DaliException e) {
61969       {
61970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61971       };
61972     } catch (...) {
61973       {
61974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61975       };
61976     }
61977   }
61978
61979   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61980
61981   //argout typemap for const std::string&
61982
61983   return jresult;
61984 }
61985
61986
61987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61988   unsigned int jresult ;
61989   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61990   std::string *arg2 = 0 ;
61991   Dali::Handle *arg3 = 0 ;
61992   bool result;
61993
61994   arg1 = (Dali::Toolkit::Builder *)jarg1;
61995   if (!jarg2) {
61996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61997     return 0;
61998   }
61999   std::string arg2_str(jarg2);
62000   arg2 = &arg2_str;
62001   arg3 = (Dali::Handle *)jarg3;
62002   if (!arg3) {
62003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62004     return 0;
62005   }
62006   {
62007     try {
62008       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62009     } catch (std::out_of_range& e) {
62010       {
62011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62012       };
62013     } catch (std::exception& e) {
62014       {
62015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62016       };
62017     } catch (Dali::DaliException e) {
62018       {
62019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62020       };
62021     } catch (...) {
62022       {
62023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62024       };
62025     }
62026   }
62027
62028   jresult = result;
62029
62030   //argout typemap for const std::string&
62031
62032   return jresult;
62033 }
62034
62035
62036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62037   unsigned int jresult ;
62038   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62039   Dali::Handle *arg2 = 0 ;
62040   std::string *arg3 = 0 ;
62041   bool result;
62042
62043   arg1 = (Dali::Toolkit::Builder *)jarg1;
62044   arg2 = (Dali::Handle *)jarg2;
62045   if (!arg2) {
62046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62047     return 0;
62048   }
62049   if (!jarg3) {
62050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62051     return 0;
62052   }
62053   std::string arg3_str(jarg3);
62054   arg3 = &arg3_str;
62055   {
62056     try {
62057       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62058     } catch (std::out_of_range& e) {
62059       {
62060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62061       };
62062     } catch (std::exception& e) {
62063       {
62064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62065       };
62066     } catch (Dali::DaliException e) {
62067       {
62068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62069       };
62070     } catch (...) {
62071       {
62072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62073       };
62074     }
62075   }
62076
62077   jresult = result;
62078
62079   //argout typemap for const std::string&
62080
62081   return jresult;
62082 }
62083
62084
62085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62086   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62087   Dali::Actor arg2 ;
62088   Dali::Actor *argp2 ;
62089
62090   arg1 = (Dali::Toolkit::Builder *)jarg1;
62091   argp2 = (Dali::Actor *)jarg2;
62092   if (!argp2) {
62093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62094     return ;
62095   }
62096   arg2 = *argp2;
62097   {
62098     try {
62099       (arg1)->AddActors(arg2);
62100     } catch (std::out_of_range& e) {
62101       {
62102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62103       };
62104     } catch (std::exception& e) {
62105       {
62106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62107       };
62108     } catch (Dali::DaliException e) {
62109       {
62110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62111       };
62112     } catch (...) {
62113       {
62114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62115       };
62116     }
62117   }
62118
62119 }
62120
62121
62122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62123   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62124   std::string *arg2 = 0 ;
62125   Dali::Actor arg3 ;
62126   Dali::Actor *argp3 ;
62127
62128   arg1 = (Dali::Toolkit::Builder *)jarg1;
62129   if (!jarg2) {
62130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62131     return ;
62132   }
62133   std::string arg2_str(jarg2);
62134   arg2 = &arg2_str;
62135   argp3 = (Dali::Actor *)jarg3;
62136   if (!argp3) {
62137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62138     return ;
62139   }
62140   arg3 = *argp3;
62141   {
62142     try {
62143       (arg1)->AddActors((std::string const &)*arg2,arg3);
62144     } catch (std::out_of_range& e) {
62145       {
62146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62147       };
62148     } catch (std::exception& e) {
62149       {
62150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62151       };
62152     } catch (Dali::DaliException e) {
62153       {
62154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62155       };
62156     } catch (...) {
62157       {
62158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62159       };
62160     }
62161   }
62162
62163
62164   //argout typemap for const std::string&
62165
62166 }
62167
62168
62169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62170   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62171   std::string *arg2 = 0 ;
62172
62173   arg1 = (Dali::Toolkit::Builder *)jarg1;
62174   if (!jarg2) {
62175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62176     return ;
62177   }
62178   std::string arg2_str(jarg2);
62179   arg2 = &arg2_str;
62180   {
62181     try {
62182       (arg1)->CreateRenderTask((std::string const &)*arg2);
62183     } catch (std::out_of_range& e) {
62184       {
62185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62186       };
62187     } catch (std::exception& e) {
62188       {
62189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62190       };
62191     } catch (Dali::DaliException e) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62194       };
62195     } catch (...) {
62196       {
62197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62198       };
62199     }
62200   }
62201
62202
62203   //argout typemap for const std::string&
62204
62205 }
62206
62207
62208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62209   void * jresult ;
62210   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62211   std::string *arg2 = 0 ;
62212   Dali::FrameBufferImage result;
62213
62214   arg1 = (Dali::Toolkit::Builder *)jarg1;
62215   if (!jarg2) {
62216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62217     return 0;
62218   }
62219   std::string arg2_str(jarg2);
62220   arg2 = &arg2_str;
62221   {
62222     try {
62223       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62224     } catch (std::out_of_range& e) {
62225       {
62226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62227       };
62228     } catch (std::exception& e) {
62229       {
62230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62231       };
62232     } catch (Dali::DaliException e) {
62233       {
62234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62235       };
62236     } catch (...) {
62237       {
62238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62239       };
62240     }
62241   }
62242
62243   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62244
62245   //argout typemap for const std::string&
62246
62247   return jresult;
62248 }
62249
62250
62251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62252   void * jresult ;
62253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62254   std::string *arg2 = 0 ;
62255   Dali::Path result;
62256
62257   arg1 = (Dali::Toolkit::Builder *)jarg1;
62258   if (!jarg2) {
62259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62260     return 0;
62261   }
62262   std::string arg2_str(jarg2);
62263   arg2 = &arg2_str;
62264   {
62265     try {
62266       result = (arg1)->GetPath((std::string const &)*arg2);
62267     } catch (std::out_of_range& e) {
62268       {
62269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62270       };
62271     } catch (std::exception& e) {
62272       {
62273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62274       };
62275     } catch (Dali::DaliException e) {
62276       {
62277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62278       };
62279     } catch (...) {
62280       {
62281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62282       };
62283     }
62284   }
62285
62286   jresult = new Dali::Path((const Dali::Path &)result);
62287
62288   //argout typemap for const std::string&
62289
62290   return jresult;
62291 }
62292
62293
62294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62295   void * jresult ;
62296   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62297   std::string *arg2 = 0 ;
62298   Dali::PathConstrainer result;
62299
62300   arg1 = (Dali::Toolkit::Builder *)jarg1;
62301   if (!jarg2) {
62302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62303     return 0;
62304   }
62305   std::string arg2_str(jarg2);
62306   arg2 = &arg2_str;
62307   {
62308     try {
62309       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62310     } catch (std::out_of_range& e) {
62311       {
62312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62313       };
62314     } catch (std::exception& e) {
62315       {
62316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62317       };
62318     } catch (Dali::DaliException e) {
62319       {
62320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62321       };
62322     } catch (...) {
62323       {
62324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62325       };
62326     }
62327   }
62328
62329   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62330
62331   //argout typemap for const std::string&
62332
62333   return jresult;
62334 }
62335
62336
62337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62338   void * jresult ;
62339   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62340   std::string *arg2 = 0 ;
62341   Dali::LinearConstrainer result;
62342
62343   arg1 = (Dali::Toolkit::Builder *)jarg1;
62344   if (!jarg2) {
62345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62346     return 0;
62347   }
62348   std::string arg2_str(jarg2);
62349   arg2 = &arg2_str;
62350   {
62351     try {
62352       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62353     } catch (std::out_of_range& e) {
62354       {
62355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62356       };
62357     } catch (std::exception& e) {
62358       {
62359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62360       };
62361     } catch (Dali::DaliException e) {
62362       {
62363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62364       };
62365     } catch (...) {
62366       {
62367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62368       };
62369     }
62370   }
62371
62372   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62373
62374   //argout typemap for const std::string&
62375
62376   return jresult;
62377 }
62378
62379
62380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62381   void * jresult ;
62382   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62383   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62384
62385   arg1 = (Dali::Toolkit::Builder *)jarg1;
62386   {
62387     try {
62388       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62389     } catch (std::out_of_range& e) {
62390       {
62391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62392       };
62393     } catch (std::exception& e) {
62394       {
62395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62396       };
62397     } catch (Dali::DaliException e) {
62398       {
62399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62400       };
62401     } catch (...) {
62402       {
62403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62404       };
62405     }
62406   }
62407
62408   jresult = (void *)result;
62409   return jresult;
62410 }
62411
62412
62413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62414   void * jresult ;
62415   Dali::Toolkit::TransitionData *result = 0 ;
62416
62417   {
62418     try {
62419       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62420     } catch (std::out_of_range& e) {
62421       {
62422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62423       };
62424     } catch (std::exception& e) {
62425       {
62426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62427       };
62428     } catch (Dali::DaliException e) {
62429       {
62430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62431       };
62432     } catch (...) {
62433       {
62434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62435       };
62436     }
62437   }
62438
62439   jresult = (void *)result;
62440   return jresult;
62441 }
62442
62443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62444   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62445
62446   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62447   {
62448     try {
62449       delete arg1;
62450     } catch (std::out_of_range& e) {
62451       {
62452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62453       };
62454     } catch (std::exception& e) {
62455       {
62456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62457       };
62458     } catch (Dali::DaliException e) {
62459       {
62460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62461       };
62462     } catch (...) {
62463       {
62464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62465       };
62466     }
62467   }
62468
62469 }
62470
62471
62472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62473   void * jresult ;
62474   Dali::Property::Map *arg1 = 0 ;
62475   Dali::Toolkit::TransitionData result;
62476
62477   arg1 = (Dali::Property::Map *)jarg1;
62478   if (!arg1) {
62479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62480     return 0;
62481   }
62482   {
62483     try {
62484       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62485     } catch (std::out_of_range& e) {
62486       {
62487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62488       };
62489     } catch (std::exception& e) {
62490       {
62491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62492       };
62493     } catch (Dali::DaliException e) {
62494       {
62495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62496       };
62497     } catch (...) {
62498       {
62499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62500       };
62501     }
62502   }
62503
62504   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62505   return jresult;
62506 }
62507
62508
62509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62510   void * jresult ;
62511   Dali::Property::Array *arg1 = 0 ;
62512   Dali::Toolkit::TransitionData result;
62513
62514   arg1 = (Dali::Property::Array *)jarg1;
62515   if (!arg1) {
62516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62517     return 0;
62518   }
62519   {
62520     try {
62521       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62522     } catch (std::out_of_range& e) {
62523       {
62524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62525       };
62526     } catch (std::exception& e) {
62527       {
62528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62529       };
62530     } catch (Dali::DaliException e) {
62531       {
62532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62533       };
62534     } catch (...) {
62535       {
62536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62537       };
62538     }
62539   }
62540
62541   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62542   return jresult;
62543 }
62544
62545
62546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62547   void * jresult ;
62548   Dali::BaseHandle arg1 ;
62549   Dali::BaseHandle *argp1 ;
62550   Dali::Toolkit::TransitionData result;
62551
62552   argp1 = (Dali::BaseHandle *)jarg1;
62553   if (!argp1) {
62554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62555     return 0;
62556   }
62557   arg1 = *argp1;
62558   {
62559     try {
62560       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62561     } catch (std::out_of_range& e) {
62562       {
62563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (std::exception& e) {
62566       {
62567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62568       };
62569     } catch (Dali::DaliException e) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62572       };
62573     } catch (...) {
62574       {
62575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62576       };
62577     }
62578   }
62579
62580   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62581   return jresult;
62582 }
62583
62584
62585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62586   void * jresult ;
62587   Dali::Toolkit::TransitionData *arg1 = 0 ;
62588   Dali::Toolkit::TransitionData *result = 0 ;
62589
62590   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62591   if (!arg1) {
62592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62593     return 0;
62594   }
62595   {
62596     try {
62597       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62598     } catch (std::out_of_range& e) {
62599       {
62600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62601       };
62602     } catch (std::exception& e) {
62603       {
62604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62605       };
62606     } catch (Dali::DaliException e) {
62607       {
62608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62609       };
62610     } catch (...) {
62611       {
62612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62613       };
62614     }
62615   }
62616
62617   jresult = (void *)result;
62618   return jresult;
62619 }
62620
62621
62622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62623   void * jresult ;
62624   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62625   Dali::Toolkit::TransitionData *arg2 = 0 ;
62626   Dali::Toolkit::TransitionData *result = 0 ;
62627
62628   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62629   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62630   if (!arg2) {
62631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62632     return 0;
62633   }
62634   {
62635     try {
62636       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62637     } catch (std::out_of_range& e) {
62638       {
62639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62640       };
62641     } catch (std::exception& e) {
62642       {
62643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62644       };
62645     } catch (Dali::DaliException e) {
62646       {
62647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62648       };
62649     } catch (...) {
62650       {
62651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62652       };
62653     }
62654   }
62655
62656   jresult = (void *)result;
62657   return jresult;
62658 }
62659
62660
62661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62662   unsigned long jresult ;
62663   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62664   size_t result;
62665
62666   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62667   {
62668     try {
62669       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62670     } catch (std::out_of_range& e) {
62671       {
62672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62673       };
62674     } catch (std::exception& e) {
62675       {
62676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62677       };
62678     } catch (Dali::DaliException e) {
62679       {
62680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62681       };
62682     } catch (...) {
62683       {
62684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62685       };
62686     }
62687   }
62688
62689   jresult = (unsigned long)result;
62690   return jresult;
62691 }
62692
62693
62694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62695   void * jresult ;
62696   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62697   size_t arg2 ;
62698   Dali::Property::Map result;
62699
62700   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62701   arg2 = (size_t)jarg2;
62702   {
62703     try {
62704       result = (arg1)->GetAnimatorAt(arg2);
62705     } catch (std::out_of_range& e) {
62706       {
62707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62708       };
62709     } catch (std::exception& e) {
62710       {
62711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62712       };
62713     } catch (Dali::DaliException e) {
62714       {
62715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62716       };
62717     } catch (...) {
62718       {
62719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62720       };
62721     }
62722   }
62723
62724   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62725   return jresult;
62726 }
62727
62728
62729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62730   int jresult ;
62731   int result;
62732
62733   {
62734     try {
62735       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62736     } catch (std::out_of_range& e) {
62737       {
62738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62739       };
62740     } catch (std::exception& e) {
62741       {
62742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62743       };
62744     } catch (Dali::DaliException e) {
62745       {
62746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62747       };
62748     } catch (...) {
62749       {
62750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62751       };
62752     }
62753   }
62754
62755   jresult = (int)result;
62756   return jresult;
62757 }
62758
62759
62760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62761   int jresult ;
62762   int result;
62763
62764   {
62765     try {
62766       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62767     } catch (std::out_of_range& e) {
62768       {
62769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62770       };
62771     } catch (std::exception& e) {
62772       {
62773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62774       };
62775     } catch (Dali::DaliException e) {
62776       {
62777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62778       };
62779     } catch (...) {
62780       {
62781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62782       };
62783     }
62784   }
62785
62786   jresult = (int)result;
62787   return jresult;
62788 }
62789
62790
62791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62792   int jresult ;
62793   int result;
62794
62795   {
62796     try {
62797       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62798     } catch (std::out_of_range& e) {
62799       {
62800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62801       };
62802     } catch (std::exception& e) {
62803       {
62804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62805       };
62806     } catch (Dali::DaliException e) {
62807       {
62808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62809       };
62810     } catch (...) {
62811       {
62812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62813       };
62814     }
62815   }
62816
62817   jresult = (int)result;
62818   return jresult;
62819 }
62820
62821
62822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62823   int jresult ;
62824   int result;
62825
62826   {
62827     try {
62828       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62829     } catch (std::out_of_range& e) {
62830       {
62831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62832       };
62833     } catch (std::exception& e) {
62834       {
62835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62836       };
62837     } catch (Dali::DaliException e) {
62838       {
62839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62840       };
62841     } catch (...) {
62842       {
62843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62844       };
62845     }
62846   }
62847
62848   jresult = (int)result;
62849   return jresult;
62850 }
62851
62852
62853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62854   int jresult ;
62855   int result;
62856
62857   {
62858     try {
62859       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
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 = (int)result;
62880   return jresult;
62881 }
62882
62883
62884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62885   int jresult ;
62886   int result;
62887
62888   {
62889     try {
62890       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62891     } catch (std::out_of_range& e) {
62892       {
62893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62894       };
62895     } catch (std::exception& e) {
62896       {
62897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62898       };
62899     } catch (Dali::DaliException e) {
62900       {
62901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62902       };
62903     } catch (...) {
62904       {
62905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62906       };
62907     }
62908   }
62909
62910   jresult = (int)result;
62911   return jresult;
62912 }
62913
62914
62915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62916   int jresult ;
62917   int result;
62918
62919   {
62920     try {
62921       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62922     } catch (std::out_of_range& e) {
62923       {
62924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62925       };
62926     } catch (std::exception& e) {
62927       {
62928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62929       };
62930     } catch (Dali::DaliException e) {
62931       {
62932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62933       };
62934     } catch (...) {
62935       {
62936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62937       };
62938     }
62939   }
62940
62941   jresult = (int)result;
62942   return jresult;
62943 }
62944
62945
62946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62947   int jresult ;
62948   int result;
62949
62950   {
62951     try {
62952       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62953     } catch (std::out_of_range& e) {
62954       {
62955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62956       };
62957     } catch (std::exception& e) {
62958       {
62959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62960       };
62961     } catch (Dali::DaliException e) {
62962       {
62963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62964       };
62965     } catch (...) {
62966       {
62967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62968       };
62969     }
62970   }
62971
62972   jresult = (int)result;
62973   return jresult;
62974 }
62975
62976
62977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62978   int jresult ;
62979   int result;
62980
62981   {
62982     try {
62983       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62984     } catch (std::out_of_range& e) {
62985       {
62986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62987       };
62988     } catch (std::exception& e) {
62989       {
62990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62991       };
62992     } catch (Dali::DaliException e) {
62993       {
62994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62995       };
62996     } catch (...) {
62997       {
62998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62999       };
63000     }
63001   }
63002
63003   jresult = (int)result;
63004   return jresult;
63005 }
63006
63007
63008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63009   int jresult ;
63010   int result;
63011
63012   {
63013     try {
63014       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63015     } catch (std::out_of_range& e) {
63016       {
63017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63018       };
63019     } catch (std::exception& e) {
63020       {
63021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63022       };
63023     } catch (Dali::DaliException e) {
63024       {
63025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63026       };
63027     } catch (...) {
63028       {
63029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63030       };
63031     }
63032   }
63033
63034   jresult = (int)result;
63035   return jresult;
63036 }
63037
63038
63039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63040   int jresult ;
63041   int result;
63042
63043   {
63044     try {
63045       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63046     } catch (std::out_of_range& e) {
63047       {
63048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63049       };
63050     } catch (std::exception& e) {
63051       {
63052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63053       };
63054     } catch (Dali::DaliException e) {
63055       {
63056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63057       };
63058     } catch (...) {
63059       {
63060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63061       };
63062     }
63063   }
63064
63065   jresult = (int)result;
63066   return jresult;
63067 }
63068
63069
63070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63071   int jresult ;
63072   int result;
63073
63074   {
63075     try {
63076       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63084       };
63085     } catch (Dali::DaliException e) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63088       };
63089     } catch (...) {
63090       {
63091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63092       };
63093     }
63094   }
63095
63096   jresult = (int)result;
63097   return jresult;
63098 }
63099
63100
63101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63102   int jresult ;
63103   int result;
63104
63105   {
63106     try {
63107       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63108     } catch (std::out_of_range& e) {
63109       {
63110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63111       };
63112     } catch (std::exception& e) {
63113       {
63114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63115       };
63116     } catch (Dali::DaliException e) {
63117       {
63118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63119       };
63120     } catch (...) {
63121       {
63122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63123       };
63124     }
63125   }
63126
63127   jresult = (int)result;
63128   return jresult;
63129 }
63130
63131
63132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63133   int jresult ;
63134   int result;
63135
63136   {
63137     try {
63138       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63139     } catch (std::out_of_range& e) {
63140       {
63141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63142       };
63143     } catch (std::exception& e) {
63144       {
63145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63146       };
63147     } catch (Dali::DaliException e) {
63148       {
63149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63150       };
63151     } catch (...) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63154       };
63155     }
63156   }
63157
63158   jresult = (int)result;
63159   return jresult;
63160 }
63161
63162
63163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63164   void * jresult ;
63165   Dali::Toolkit::Control result;
63166
63167   {
63168     try {
63169       result = Dali::Toolkit::Internal::Control::New();
63170     } catch (std::out_of_range& e) {
63171       {
63172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63173       };
63174     } catch (std::exception& e) {
63175       {
63176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63177       };
63178     } catch (Dali::DaliException e) {
63179       {
63180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63181       };
63182     } catch (...) {
63183       {
63184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63185       };
63186     }
63187   }
63188
63189   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63190   return jresult;
63191 }
63192
63193
63194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63196   std::string *arg2 = 0 ;
63197
63198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63199   if (!jarg2) {
63200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63201     return ;
63202   }
63203   std::string arg2_str(jarg2);
63204   arg2 = &arg2_str;
63205   {
63206     try {
63207       (arg1)->SetStyleName((std::string const &)*arg2);
63208     } catch (std::out_of_range& e) {
63209       {
63210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63211       };
63212     } catch (std::exception& e) {
63213       {
63214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63215       };
63216     } catch (Dali::DaliException e) {
63217       {
63218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63219       };
63220     } catch (...) {
63221       {
63222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63223       };
63224     }
63225   }
63226
63227
63228   //argout typemap for const std::string&
63229
63230 }
63231
63232
63233 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63234   char * jresult ;
63235   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63236   std::string *result = 0 ;
63237
63238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63239   {
63240     try {
63241       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63242     } catch (std::out_of_range& e) {
63243       {
63244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63245       };
63246     } catch (std::exception& e) {
63247       {
63248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63249       };
63250     } catch (Dali::DaliException e) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63253       };
63254     } catch (...) {
63255       {
63256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63257       };
63258     }
63259   }
63260
63261   jresult = SWIG_csharp_string_callback(result->c_str());
63262   return jresult;
63263 }
63264
63265
63266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63267   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63268   Dali::Vector4 *arg2 = 0 ;
63269
63270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63271   arg2 = (Dali::Vector4 *)jarg2;
63272   if (!arg2) {
63273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63274     return ;
63275   }
63276   {
63277     try {
63278       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63279     } catch (std::out_of_range& e) {
63280       {
63281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63282       };
63283     } catch (std::exception& e) {
63284       {
63285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63286       };
63287     } catch (Dali::DaliException e) {
63288       {
63289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63290       };
63291     } catch (...) {
63292       {
63293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63294       };
63295     }
63296   }
63297
63298 }
63299
63300
63301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63302   void * jresult ;
63303   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63304   Dali::Vector4 result;
63305
63306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63307   {
63308     try {
63309       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
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 = new Dali::Vector4((const Dali::Vector4 &)result);
63330   return jresult;
63331 }
63332
63333
63334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63336   Dali::Image arg2 ;
63337   Dali::Image *argp2 ;
63338
63339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63340   argp2 = (Dali::Image *)jarg2;
63341   if (!argp2) {
63342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63343     return ;
63344   }
63345   arg2 = *argp2;
63346   {
63347     try {
63348       (arg1)->SetBackgroundImage(arg2);
63349     } catch (std::out_of_range& e) {
63350       {
63351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63352       };
63353     } catch (std::exception& e) {
63354       {
63355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63356       };
63357     } catch (Dali::DaliException e) {
63358       {
63359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63360       };
63361     } catch (...) {
63362       {
63363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63364       };
63365     }
63366   }
63367
63368 }
63369
63370
63371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63373   Dali::Property::Map *arg2 = 0 ;
63374
63375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63376   arg2 = (Dali::Property::Map *)jarg2;
63377   if (!arg2) {
63378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63379     return ;
63380   }
63381   {
63382     try {
63383       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63384     } catch (std::out_of_range& e) {
63385       {
63386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63387       };
63388     } catch (std::exception& e) {
63389       {
63390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63391       };
63392     } catch (Dali::DaliException e) {
63393       {
63394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63395       };
63396     } catch (...) {
63397       {
63398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63399       };
63400     }
63401   }
63402
63403 }
63404
63405
63406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63408
63409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63410   {
63411     try {
63412       (arg1)->ClearBackground();
63413     } catch (std::out_of_range& e) {
63414       {
63415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63416       };
63417     } catch (std::exception& e) {
63418       {
63419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63420       };
63421     } catch (Dali::DaliException e) {
63422       {
63423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63424       };
63425     } catch (...) {
63426       {
63427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63428       };
63429     }
63430   }
63431
63432 }
63433
63434
63435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63437   Dali::Gesture::Type arg2 ;
63438
63439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63440   arg2 = (Dali::Gesture::Type)jarg2;
63441   {
63442     try {
63443       (arg1)->EnableGestureDetection(arg2);
63444     } catch (std::out_of_range& e) {
63445       {
63446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63447       };
63448     } catch (std::exception& e) {
63449       {
63450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63451       };
63452     } catch (Dali::DaliException e) {
63453       {
63454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63455       };
63456     } catch (...) {
63457       {
63458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63459       };
63460     }
63461   }
63462
63463 }
63464
63465
63466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63468   Dali::Gesture::Type arg2 ;
63469
63470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63471   arg2 = (Dali::Gesture::Type)jarg2;
63472   {
63473     try {
63474       (arg1)->DisableGestureDetection(arg2);
63475     } catch (std::out_of_range& e) {
63476       {
63477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63478       };
63479     } catch (std::exception& e) {
63480       {
63481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63482       };
63483     } catch (Dali::DaliException e) {
63484       {
63485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63486       };
63487     } catch (...) {
63488       {
63489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63490       };
63491     }
63492   }
63493
63494 }
63495
63496
63497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63498   void * jresult ;
63499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63500   Dali::PinchGestureDetector result;
63501
63502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63503   {
63504     try {
63505       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63506     } catch (std::out_of_range& e) {
63507       {
63508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63509       };
63510     } catch (std::exception& e) {
63511       {
63512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63513       };
63514     } catch (Dali::DaliException e) {
63515       {
63516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63517       };
63518     } catch (...) {
63519       {
63520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63521       };
63522     }
63523   }
63524
63525   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63526   return jresult;
63527 }
63528
63529
63530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63531   void * jresult ;
63532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63533   Dali::PanGestureDetector result;
63534
63535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63536   {
63537     try {
63538       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63539     } catch (std::out_of_range& e) {
63540       {
63541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63542       };
63543     } catch (std::exception& e) {
63544       {
63545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63546       };
63547     } catch (Dali::DaliException e) {
63548       {
63549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63550       };
63551     } catch (...) {
63552       {
63553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63554       };
63555     }
63556   }
63557
63558   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63559   return jresult;
63560 }
63561
63562
63563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63564   void * jresult ;
63565   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63566   Dali::TapGestureDetector result;
63567
63568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63569   {
63570     try {
63571       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63572     } catch (std::out_of_range& e) {
63573       {
63574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63575       };
63576     } catch (std::exception& e) {
63577       {
63578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63579       };
63580     } catch (Dali::DaliException e) {
63581       {
63582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63583       };
63584     } catch (...) {
63585       {
63586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63587       };
63588     }
63589   }
63590
63591   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63592   return jresult;
63593 }
63594
63595
63596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63597   void * jresult ;
63598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63599   Dali::LongPressGestureDetector result;
63600
63601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63602   {
63603     try {
63604       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
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::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63625   return jresult;
63626 }
63627
63628
63629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63631   bool arg2 ;
63632
63633   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63634   arg2 = jarg2 ? true : false;
63635   {
63636     try {
63637       (arg1)->SetKeyboardNavigationSupport(arg2);
63638     } catch (std::out_of_range& e) {
63639       {
63640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63641       };
63642     } catch (std::exception& e) {
63643       {
63644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63645       };
63646     } catch (Dali::DaliException e) {
63647       {
63648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63649       };
63650     } catch (...) {
63651       {
63652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63653       };
63654     }
63655   }
63656
63657 }
63658
63659
63660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63661   unsigned int jresult ;
63662   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63663   bool result;
63664
63665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63666   {
63667     try {
63668       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63669     } catch (std::out_of_range& e) {
63670       {
63671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63672       };
63673     } catch (std::exception& e) {
63674       {
63675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63676       };
63677     } catch (Dali::DaliException e) {
63678       {
63679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63680       };
63681     } catch (...) {
63682       {
63683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63684       };
63685     }
63686   }
63687
63688   jresult = result;
63689   return jresult;
63690 }
63691
63692
63693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63695
63696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63697   {
63698     try {
63699       (arg1)->SetKeyInputFocus();
63700     } catch (std::out_of_range& e) {
63701       {
63702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63703       };
63704     } catch (std::exception& e) {
63705       {
63706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63707       };
63708     } catch (Dali::DaliException e) {
63709       {
63710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63711       };
63712     } catch (...) {
63713       {
63714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63715       };
63716     }
63717   }
63718
63719 }
63720
63721
63722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63723   unsigned int jresult ;
63724   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63725   bool result;
63726
63727   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63728   {
63729     try {
63730       result = (bool)(arg1)->HasKeyInputFocus();
63731     } catch (std::out_of_range& e) {
63732       {
63733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63734       };
63735     } catch (std::exception& e) {
63736       {
63737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63738       };
63739     } catch (Dali::DaliException e) {
63740       {
63741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63742       };
63743     } catch (...) {
63744       {
63745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63746       };
63747     }
63748   }
63749
63750   jresult = result;
63751   return jresult;
63752 }
63753
63754
63755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63757
63758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63759   {
63760     try {
63761       (arg1)->ClearKeyInputFocus();
63762     } catch (std::out_of_range& e) {
63763       {
63764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63765       };
63766     } catch (std::exception& e) {
63767       {
63768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63769       };
63770     } catch (Dali::DaliException e) {
63771       {
63772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63773       };
63774     } catch (...) {
63775       {
63776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63777       };
63778     }
63779   }
63780
63781 }
63782
63783
63784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63786   bool arg2 ;
63787
63788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63789   arg2 = jarg2 ? true : false;
63790   {
63791     try {
63792       (arg1)->SetAsKeyboardFocusGroup(arg2);
63793     } catch (std::out_of_range& e) {
63794       {
63795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63796       };
63797     } catch (std::exception& e) {
63798       {
63799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63800       };
63801     } catch (Dali::DaliException e) {
63802       {
63803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63804       };
63805     } catch (...) {
63806       {
63807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63808       };
63809     }
63810   }
63811
63812 }
63813
63814
63815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63816   unsigned int jresult ;
63817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63818   bool result;
63819
63820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63821   {
63822     try {
63823       result = (bool)(arg1)->IsKeyboardFocusGroup();
63824     } catch (std::out_of_range& e) {
63825       {
63826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63827       };
63828     } catch (std::exception& e) {
63829       {
63830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63831       };
63832     } catch (Dali::DaliException e) {
63833       {
63834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63835       };
63836     } catch (...) {
63837       {
63838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63839       };
63840     }
63841   }
63842
63843   jresult = result;
63844   return jresult;
63845 }
63846
63847
63848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63849   void * jresult ;
63850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63851   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63852
63853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63854   {
63855     try {
63856       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63857     } catch (std::out_of_range& e) {
63858       {
63859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63860       };
63861     } catch (std::exception& e) {
63862       {
63863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63864       };
63865     } catch (Dali::DaliException e) {
63866       {
63867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63868       };
63869     } catch (...) {
63870       {
63871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63872       };
63873     }
63874   }
63875
63876   jresult = (void *)result;
63877   return jresult;
63878 }
63879
63880
63881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63882   void * jresult ;
63883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63884   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63885
63886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63887   {
63888     try {
63889       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63890     } catch (std::out_of_range& e) {
63891       {
63892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63893       };
63894     } catch (std::exception& e) {
63895       {
63896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63897       };
63898     } catch (Dali::DaliException e) {
63899       {
63900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63901       };
63902     } catch (...) {
63903       {
63904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63905       };
63906     }
63907   }
63908
63909   jresult = (void *)result;
63910   return jresult;
63911 }
63912
63913
63914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63915   void * jresult ;
63916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63917   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63918
63919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63920   {
63921     try {
63922       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63923     } catch (std::out_of_range& e) {
63924       {
63925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63926       };
63927     } catch (std::exception& e) {
63928       {
63929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63930       };
63931     } catch (Dali::DaliException e) {
63932       {
63933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63934       };
63935     } catch (...) {
63936       {
63937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63938       };
63939     }
63940   }
63941
63942   jresult = (void *)result;
63943   return jresult;
63944 }
63945
63946
63947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63949   int arg2 ;
63950   SwigDirector_ViewImpl *darg = 0;
63951
63952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63953   arg2 = (int)jarg2;
63954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63955   if(!darg) {
63956     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63957     return;
63958   }
63959   {
63960     try {
63961       if(darg) {
63962         (darg)->OnStageConnection(arg2);
63963       }
63964     } catch (std::out_of_range& e) {
63965       {
63966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63967       };
63968     } catch (std::exception& e) {
63969       {
63970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63971       };
63972     } catch (Dali::DaliException e) {
63973       {
63974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63975       };
63976     } catch (...) {
63977       {
63978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63979       };
63980     }
63981   }
63982
63983 }
63984
63985
63986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63988   int arg2 ;
63989   SwigDirector_ViewImpl *darg = 0;
63990
63991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63992   arg2 = (int)jarg2;
63993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63994   if(!darg) {
63995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63996     return;
63997   }
63998   {
63999     try {
64000       if(darg) {
64001         (darg)->OnStageConnectionSwigPublic(arg2);
64002       }
64003     } catch (std::out_of_range& e) {
64004       {
64005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64006       };
64007     } catch (std::exception& e) {
64008       {
64009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64010       };
64011     } catch (Dali::DaliException e) {
64012       {
64013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64014       };
64015     } catch (...) {
64016       {
64017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64018       };
64019     }
64020   }
64021
64022 }
64023
64024
64025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64027   SwigDirector_ViewImpl *darg = 0;
64028
64029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64030   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64031   if(!darg) {
64032     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64033     return;
64034   }
64035   {
64036     try {
64037       if(darg) {
64038         (darg)->OnStageDisconnection();
64039       }
64040     } catch (std::out_of_range& e) {
64041       {
64042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64043       };
64044     } catch (std::exception& e) {
64045       {
64046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64047       };
64048     } catch (Dali::DaliException e) {
64049       {
64050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64051       };
64052     } catch (...) {
64053       {
64054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64055       };
64056     }
64057   }
64058
64059 }
64060
64061
64062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64064   SwigDirector_ViewImpl *darg = 0;
64065
64066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64067   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64068   if(!darg) {
64069     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64070     return;
64071   }
64072   {
64073     try {
64074       if(darg) {
64075         (darg)->OnStageDisconnectionSwigPublic();
64076       }
64077     } catch (std::out_of_range& e) {
64078       {
64079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64080       };
64081     } catch (std::exception& e) {
64082       {
64083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64084       };
64085     } catch (Dali::DaliException e) {
64086       {
64087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64088       };
64089     } catch (...) {
64090       {
64091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64092       };
64093     }
64094   }
64095
64096 }
64097
64098
64099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64101   Dali::Actor *arg2 = 0 ;
64102   SwigDirector_ViewImpl *darg = 0;
64103
64104   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64105   arg2 = (Dali::Actor *)jarg2;
64106   if (!arg2) {
64107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64108     return ;
64109   }
64110   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64111   if(!darg) {
64112     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64113     return;
64114   }
64115   {
64116     try {
64117       if(darg) {
64118         (darg)->OnChildAdd(*arg2);
64119       }
64120     } catch (std::out_of_range& e) {
64121       {
64122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64123       };
64124     } catch (std::exception& e) {
64125       {
64126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64127       };
64128     } catch (Dali::DaliException e) {
64129       {
64130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64131       };
64132     } catch (...) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64135       };
64136     }
64137   }
64138
64139 }
64140
64141
64142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64144   Dali::Actor *arg2 = 0 ;
64145   SwigDirector_ViewImpl *darg = 0;
64146
64147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64148   arg2 = (Dali::Actor *)jarg2;
64149   if (!arg2) {
64150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64151     return ;
64152   }
64153   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64154   if(!darg) {
64155     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64156     return;
64157   }
64158   {
64159     try {
64160       if(darg) {
64161           (darg)->OnChildAddSwigPublic(*arg2);
64162       }
64163     } catch (std::out_of_range& e) {
64164       {
64165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64166       };
64167     } catch (std::exception& e) {
64168       {
64169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64170       };
64171     } catch (Dali::DaliException e) {
64172       {
64173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64174       };
64175     } catch (...) {
64176       {
64177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64178       };
64179     }
64180   }
64181
64182 }
64183
64184
64185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64187   Dali::Actor *arg2 = 0 ;
64188   SwigDirector_ViewImpl *darg = 0;
64189
64190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64191   arg2 = (Dali::Actor *)jarg2;
64192   if (!arg2) {
64193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64194     return ;
64195   }
64196   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64197   if(!darg) {
64198     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64199     return;
64200   }
64201   {
64202     try {
64203       if(darg) {
64204         (darg)->OnChildRemove(*arg2);
64205       }
64206     } catch (std::out_of_range& e) {
64207       {
64208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64209       };
64210     } catch (std::exception& e) {
64211       {
64212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64213       };
64214     } catch (Dali::DaliException e) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64217       };
64218     } catch (...) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64221       };
64222     }
64223   }
64224
64225 }
64226
64227
64228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64230   Dali::Actor *arg2 = 0 ;
64231   SwigDirector_ViewImpl *darg = 0;
64232
64233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64234   arg2 = (Dali::Actor *)jarg2;
64235   if (!arg2) {
64236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64237     return ;
64238   }
64239   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64240   if(!darg) {
64241     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64242     return;
64243   }
64244   {
64245     try {
64246       if(darg) {
64247         (darg)->OnChildRemoveSwigPublic(*arg2);
64248       }
64249     } catch (std::out_of_range& e) {
64250       {
64251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64252       };
64253     } catch (std::exception& e) {
64254       {
64255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64256       };
64257     } catch (Dali::DaliException e) {
64258       {
64259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64260       };
64261     } catch (...) {
64262       {
64263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64264       };
64265     }
64266   }
64267
64268 }
64269
64270
64271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64272   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64273   Dali::Property::Index arg2 ;
64274   Dali::Property::Value arg3 ;
64275   Dali::Property::Value *argp3 ;
64276   SwigDirector_ViewImpl *darg = 0;
64277
64278   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64279   arg2 = (Dali::Property::Index)jarg2;
64280   argp3 = (Dali::Property::Value *)jarg3;
64281   if (!argp3) {
64282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64283     return ;
64284   }
64285   arg3 = *argp3;
64286   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64287   if (!darg) {
64288     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64289     return;
64290   }
64291   {
64292     try {
64293       (darg)->OnPropertySet(arg2,arg3);
64294     } catch (std::out_of_range& e) {
64295       {
64296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64297       };
64298     } catch (std::exception& e) {
64299       {
64300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64301       };
64302     } catch (Dali::DaliException e) {
64303       {
64304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64305       };
64306     } catch (...) {
64307       {
64308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64309       };
64310     }
64311   }
64312
64313 }
64314
64315
64316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64317   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64318   Dali::Property::Index arg2 ;
64319   Dali::Property::Value arg3 ;
64320   Dali::Property::Value *argp3 ;
64321   SwigDirector_ViewImpl *darg = 0;
64322
64323   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64324   arg2 = (Dali::Property::Index)jarg2;
64325   argp3 = (Dali::Property::Value *)jarg3;
64326   if (!argp3) {
64327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64328     return ;
64329   }
64330   arg3 = *argp3;
64331   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64332   if (!darg) {
64333     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64334     return;
64335   }
64336   {
64337     try {
64338       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64339     } catch (std::out_of_range& e) {
64340       {
64341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64342       };
64343     } catch (std::exception& e) {
64344       {
64345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64346       };
64347     } catch (Dali::DaliException e) {
64348       {
64349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64354       };
64355     }
64356   }
64357
64358 }
64359
64360
64361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64363   Dali::Vector3 *arg2 = 0 ;
64364   SwigDirector_ViewImpl *darg = 0;
64365
64366   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64367   arg2 = (Dali::Vector3 *)jarg2;
64368   if (!arg2) {
64369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64370     return ;
64371   }
64372   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64373   if (!darg) {
64374     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64375     return;
64376   }
64377   {
64378     try {
64379       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64380     } catch (std::out_of_range& e) {
64381       {
64382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64383       };
64384     } catch (std::exception& e) {
64385       {
64386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64387       };
64388     } catch (Dali::DaliException e) {
64389       {
64390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64391       };
64392     } catch (...) {
64393       {
64394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64395       };
64396     }
64397   }
64398
64399 }
64400
64401
64402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64403   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64404   Dali::Vector3 *arg2 = 0 ;
64405   SwigDirector_ViewImpl *darg = 0;
64406
64407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64408   arg2 = (Dali::Vector3 *)jarg2;
64409   if (!arg2) {
64410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64411     return ;
64412   }
64413   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64414   if (!darg) {
64415     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64416     return;
64417   }
64418   {
64419     try {
64420       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64421     } catch (std::out_of_range& e) {
64422       {
64423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64424       };
64425     } catch (std::exception& e) {
64426       {
64427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64428       };
64429     } catch (Dali::DaliException e) {
64430       {
64431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64432       };
64433     } catch (...) {
64434       {
64435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64436       };
64437     }
64438   }
64439
64440 }
64441
64442
64443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64445   Dali::Animation *arg2 = 0 ;
64446   Dali::Vector3 *arg3 = 0 ;
64447   SwigDirector_ViewImpl *darg = 0;
64448
64449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64450   arg2 = (Dali::Animation *)jarg2;
64451   if (!arg2) {
64452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64453     return ;
64454   }
64455   arg3 = (Dali::Vector3 *)jarg3;
64456   if (!arg3) {
64457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64458     return ;
64459   }
64460   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64461   if (!darg) {
64462     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64463     return;
64464   }
64465   {
64466     try {
64467       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64468     } catch (std::out_of_range& e) {
64469       {
64470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64471       };
64472     } catch (std::exception& e) {
64473       {
64474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64475       };
64476     } catch (Dali::DaliException e) {
64477       {
64478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64479       };
64480     } catch (...) {
64481       {
64482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64483       };
64484     }
64485   }
64486
64487 }
64488
64489
64490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64491   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64492   Dali::Animation *arg2 = 0 ;
64493   Dali::Vector3 *arg3 = 0 ;
64494   SwigDirector_ViewImpl *darg = 0;
64495
64496   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64497   arg2 = (Dali::Animation *)jarg2;
64498   if (!arg2) {
64499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64500     return ;
64501   }
64502   arg3 = (Dali::Vector3 *)jarg3;
64503   if (!arg3) {
64504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64505     return ;
64506   }
64507   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64508   if (!darg) {
64509     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64510     return;
64511   }
64512   {
64513     try {
64514       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64515     } catch (std::out_of_range& e) {
64516       {
64517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64518       };
64519     } catch (std::exception& e) {
64520       {
64521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64522       };
64523     } catch (Dali::DaliException e) {
64524       {
64525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64526       };
64527     } catch (...) {
64528       {
64529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64530       };
64531     }
64532   }
64533
64534 }
64535
64536
64537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64538   unsigned int jresult ;
64539   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64540   Dali::TouchEvent *arg2 = 0 ;
64541   SwigDirector_ViewImpl *darg = 0;
64542   bool result;
64543
64544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64545   arg2 = (Dali::TouchEvent *)jarg2;
64546   if (!arg2) {
64547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64548     return 0;
64549   }
64550   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64551   if (!darg) {
64552     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64553     return 0;
64554   }
64555   {
64556     try {
64557       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64558     } catch (std::out_of_range& e) {
64559       {
64560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64561       };
64562     } catch (std::exception& e) {
64563       {
64564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64565       };
64566     } catch (Dali::DaliException e) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64569       };
64570     } catch (...) {
64571       {
64572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64573       };
64574     }
64575   }
64576
64577   jresult = result;
64578   return jresult;
64579 }
64580
64581
64582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64583   unsigned int jresult ;
64584   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64585   Dali::TouchEvent *arg2 = 0 ;
64586   SwigDirector_ViewImpl *darg = 0;
64587   bool result;
64588
64589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64590   arg2 = (Dali::TouchEvent *)jarg2;
64591   if (!arg2) {
64592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64593     return 0;
64594   }
64595   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64596   if (!darg) {
64597     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64598     return 0;
64599   }
64600   {
64601     try {
64602       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64603     } catch (std::out_of_range& e) {
64604       {
64605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64606       };
64607     } catch (std::exception& e) {
64608       {
64609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64610       };
64611     } catch (Dali::DaliException e) {
64612       {
64613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64614       };
64615     } catch (...) {
64616       {
64617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64618       };
64619     }
64620   }
64621
64622   jresult = result;
64623   return jresult;
64624 }
64625
64626
64627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64628   unsigned int jresult ;
64629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64630   Dali::HoverEvent *arg2 = 0 ;
64631   SwigDirector_ViewImpl *darg = 0;
64632   bool result;
64633
64634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64635   arg2 = (Dali::HoverEvent *)jarg2;
64636   if (!arg2) {
64637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64638     return 0;
64639   }
64640   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64641   if (!darg) {
64642     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64643     return 0;
64644   }
64645   {
64646     try {
64647       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64648     } catch (std::out_of_range& e) {
64649       {
64650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64651       };
64652     } catch (std::exception& e) {
64653       {
64654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64655       };
64656     } catch (Dali::DaliException e) {
64657       {
64658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64659       };
64660     } catch (...) {
64661       {
64662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64663       };
64664     }
64665   }
64666
64667   jresult = result;
64668   return jresult;
64669 }
64670
64671
64672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64673   unsigned int jresult ;
64674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64675   Dali::HoverEvent *arg2 = 0 ;
64676   SwigDirector_ViewImpl *darg = 0;
64677   bool result;
64678
64679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64680   arg2 = (Dali::HoverEvent *)jarg2;
64681   if (!arg2) {
64682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64683     return 0;
64684   }
64685   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64686   if (!darg) {
64687     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64688     return 0;
64689   }
64690   {
64691     try {
64692       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64693     } catch (std::out_of_range& e) {
64694       {
64695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64696       };
64697     } catch (std::exception& e) {
64698       {
64699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64700       };
64701     } catch (Dali::DaliException e) {
64702       {
64703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64704       };
64705     } catch (...) {
64706       {
64707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64708       };
64709     }
64710   }
64711
64712   jresult = result;
64713   return jresult;
64714 }
64715
64716
64717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64718   unsigned int jresult ;
64719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64720   Dali::KeyEvent *arg2 = 0 ;
64721   SwigDirector_ViewImpl *darg = 0;
64722   bool result;
64723
64724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64725   arg2 = (Dali::KeyEvent *)jarg2;
64726   if (!arg2) {
64727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64728     return 0;
64729   }
64730   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64731   if (!darg) {
64732     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64733     return 0;
64734   }
64735   {
64736     try {
64737       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64738     } catch (std::out_of_range& e) {
64739       {
64740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64741       };
64742     } catch (std::exception& e) {
64743       {
64744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64745       };
64746     } catch (Dali::DaliException e) {
64747       {
64748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64749       };
64750     } catch (...) {
64751       {
64752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64753       };
64754     }
64755   }
64756
64757   jresult = result;
64758   return jresult;
64759 }
64760
64761
64762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64763   unsigned int jresult ;
64764   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64765   Dali::KeyEvent *arg2 = 0 ;
64766   SwigDirector_ViewImpl *darg = 0;
64767   bool result;
64768
64769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64770   arg2 = (Dali::KeyEvent *)jarg2;
64771   if (!arg2) {
64772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64773     return 0;
64774   }
64775   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64776   if (!darg) {
64777     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64778     return 0;
64779   }
64780   {
64781     try {
64782       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64783     } catch (std::out_of_range& e) {
64784       {
64785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64786       };
64787     } catch (std::exception& e) {
64788       {
64789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64790       };
64791     } catch (Dali::DaliException e) {
64792       {
64793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64794       };
64795     } catch (...) {
64796       {
64797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64798       };
64799     }
64800   }
64801
64802   jresult = result;
64803   return jresult;
64804 }
64805
64806
64807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64808   unsigned int jresult ;
64809   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64810   Dali::WheelEvent *arg2 = 0 ;
64811   SwigDirector_ViewImpl *darg = 0;
64812   bool result;
64813
64814   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64815   arg2 = (Dali::WheelEvent *)jarg2;
64816   if (!arg2) {
64817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64818     return 0;
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 0;
64824   }
64825   {
64826     try {
64827       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64828     } catch (std::out_of_range& e) {
64829       {
64830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64831       };
64832     } catch (std::exception& e) {
64833       {
64834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64835       };
64836     } catch (Dali::DaliException e) {
64837       {
64838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64839       };
64840     } catch (...) {
64841       {
64842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64843       };
64844     }
64845   }
64846
64847   jresult = result;
64848   return jresult;
64849 }
64850
64851
64852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64853   unsigned int jresult ;
64854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64855   Dali::WheelEvent *arg2 = 0 ;
64856   SwigDirector_ViewImpl *darg = 0;
64857   bool result;
64858
64859   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64860   arg2 = (Dali::WheelEvent *)jarg2;
64861   if (!arg2) {
64862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64863     return 0;
64864   }
64865   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64866   if (!darg) {
64867     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64868     return 0;
64869   }
64870   {
64871     try {
64872       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64873     } catch (std::out_of_range& e) {
64874       {
64875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64876       };
64877     } catch (std::exception& e) {
64878       {
64879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64880       };
64881     } catch (Dali::DaliException e) {
64882       {
64883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64884       };
64885     } catch (...) {
64886       {
64887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64888       };
64889     }
64890   }
64891
64892   jresult = result;
64893   return jresult;
64894 }
64895
64896
64897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64898   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64899   Dali::Vector2 *arg2 = 0 ;
64900   Dali::RelayoutContainer *arg3 = 0 ;
64901   SwigDirector_ViewImpl *darg = 0;
64902
64903   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64904   arg2 = (Dali::Vector2 *)jarg2;
64905   if (!arg2) {
64906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64907     return ;
64908   }
64909   arg3 = (Dali::RelayoutContainer *)jarg3;
64910   if (!arg3) {
64911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64912     return ;
64913   }
64914   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64915   if (!darg) {
64916     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64917     return;
64918   }
64919   {
64920     try {
64921       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64922     } catch (std::out_of_range& e) {
64923       {
64924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64925       };
64926     } catch (std::exception& e) {
64927       {
64928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64929       };
64930     } catch (Dali::DaliException e) {
64931       {
64932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64933       };
64934     } catch (...) {
64935       {
64936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64937       };
64938     }
64939   }
64940
64941 }
64942
64943
64944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64946   Dali::Vector2 *arg2 = 0 ;
64947   Dali::RelayoutContainer *arg3 = 0 ;
64948   SwigDirector_ViewImpl *darg = 0;
64949
64950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64951   arg2 = (Dali::Vector2 *)jarg2;
64952   if (!arg2) {
64953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64954     return ;
64955   }
64956   arg3 = (Dali::RelayoutContainer *)jarg3;
64957   if (!arg3) {
64958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64959     return ;
64960   }
64961   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64962   if (!darg) {
64963     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64964     return;
64965   }
64966   {
64967     try {
64968       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64969     } catch (std::out_of_range& e) {
64970       {
64971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64972       };
64973     } catch (std::exception& e) {
64974       {
64975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64976       };
64977     } catch (Dali::DaliException e) {
64978       {
64979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64980       };
64981     } catch (...) {
64982       {
64983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64984       };
64985     }
64986   }
64987
64988 }
64989
64990
64991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64993   Dali::ResizePolicy::Type arg2 ;
64994   Dali::Dimension::Type arg3 ;
64995   SwigDirector_ViewImpl *darg = 0;
64996
64997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64998   arg2 = (Dali::ResizePolicy::Type)jarg2;
64999   arg3 = (Dali::Dimension::Type)jarg3;
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;
65004   }
65005   {
65006     try {
65007       (darg)->OnSetResizePolicy(arg2,arg3);
65008     } catch (std::out_of_range& e) {
65009       {
65010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65011       };
65012     } catch (std::exception& e) {
65013       {
65014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65015       };
65016     } catch (Dali::DaliException e) {
65017       {
65018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65019       };
65020     } catch (...) {
65021       {
65022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65023       };
65024     }
65025   }
65026
65027 }
65028
65029
65030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65032   Dali::ResizePolicy::Type arg2 ;
65033   Dali::Dimension::Type arg3 ;
65034   SwigDirector_ViewImpl *darg = 0;
65035
65036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65037   arg2 = (Dali::ResizePolicy::Type)jarg2;
65038   arg3 = (Dali::Dimension::Type)jarg3;
65039   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65040   if (!darg) {
65041     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65042     return;
65043   }
65044   {
65045     try {
65046       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65047     } catch (std::out_of_range& e) {
65048       {
65049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65050       };
65051     } catch (std::exception& e) {
65052       {
65053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65054       };
65055     } catch (Dali::DaliException e) {
65056       {
65057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65058       };
65059     } catch (...) {
65060       {
65061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65062       };
65063     }
65064   }
65065
65066 }
65067
65068
65069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65070   void * jresult ;
65071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65072   SwigDirector_ViewImpl *darg = 0;
65073   Dali::Vector3 result;
65074
65075   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65076   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65077   if (!darg) {
65078     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65079     return 0;
65080   }
65081   {
65082     try {
65083       result = (darg)->GetNaturalSize();
65084     } catch (std::out_of_range& e) {
65085       {
65086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65087       };
65088     } catch (std::exception& e) {
65089       {
65090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65091       };
65092     } catch (Dali::DaliException e) {
65093       {
65094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65095       };
65096     } catch (...) {
65097       {
65098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65099       };
65100     }
65101   }
65102
65103   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65104   return jresult;
65105 }
65106
65107
65108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65109   void * jresult ;
65110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65111   SwigDirector_ViewImpl *darg = 0;
65112   Dali::Vector3 result;
65113
65114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65115   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65116   if (!darg) {
65117     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65118     return 0;
65119   }
65120   {
65121     try {
65122       result = (darg)->GetNaturalSizeSwigPublic();
65123     } catch (std::out_of_range& e) {
65124       {
65125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65126       };
65127     } catch (std::exception& e) {
65128       {
65129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65130       };
65131     } catch (Dali::DaliException e) {
65132       {
65133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65134       };
65135     } catch (...) {
65136       {
65137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65138       };
65139     }
65140   }
65141
65142   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65143   return jresult;
65144 }
65145
65146
65147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65148   float jresult ;
65149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65150   Dali::Actor *arg2 = 0 ;
65151   Dali::Dimension::Type arg3 ;
65152   SwigDirector_ViewImpl *darg = 0;
65153   float result;
65154
65155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65156   arg2 = (Dali::Actor *)jarg2;
65157   if (!arg2) {
65158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65159     return 0;
65160   }
65161   arg3 = (Dali::Dimension::Type)jarg3;
65162   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65163   if (!darg) {
65164     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65165     return 0;
65166   }
65167   {
65168     try {
65169       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65170     } catch (std::out_of_range& e) {
65171       {
65172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65173       };
65174     } catch (std::exception& e) {
65175       {
65176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65177       };
65178     } catch (Dali::DaliException e) {
65179       {
65180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65181       };
65182     } catch (...) {
65183       {
65184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65185       };
65186     }
65187   }
65188
65189   jresult = result;
65190   return jresult;
65191 }
65192
65193
65194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65195   float jresult ;
65196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65197   Dali::Actor *arg2 = 0 ;
65198   Dali::Dimension::Type arg3 ;
65199   SwigDirector_ViewImpl *darg = 0;
65200   float result;
65201
65202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65203   arg2 = (Dali::Actor *)jarg2;
65204   if (!arg2) {
65205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65206     return 0;
65207   }
65208   arg3 = (Dali::Dimension::Type)jarg3;
65209   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65210   if (!darg) {
65211     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65212     return 0;
65213   }
65214   {
65215     try {
65216       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65217     } catch (std::out_of_range& e) {
65218       {
65219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65220       };
65221     } catch (std::exception& e) {
65222       {
65223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65224       };
65225     } catch (Dali::DaliException e) {
65226       {
65227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65228       };
65229     } catch (...) {
65230       {
65231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65232       };
65233     }
65234   }
65235
65236   jresult = result;
65237   return jresult;
65238 }
65239
65240
65241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65242   float jresult ;
65243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65244   float arg2 ;
65245   SwigDirector_ViewImpl *darg = 0;
65246   float result;
65247
65248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65249   arg2 = (float)jarg2;
65250   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65251   if (!darg) {
65252     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65253     return 0;
65254   }
65255   {
65256     try {
65257       result = (float)(darg)->GetHeightForWidth(arg2);
65258     } catch (std::out_of_range& e) {
65259       {
65260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65261       };
65262     } catch (std::exception& e) {
65263       {
65264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65265       };
65266     } catch (Dali::DaliException e) {
65267       {
65268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65269       };
65270     } catch (...) {
65271       {
65272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65273       };
65274     }
65275   }
65276
65277   jresult = result;
65278   return jresult;
65279 }
65280
65281
65282 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65283   float jresult ;
65284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65285   float arg2 ;
65286   SwigDirector_ViewImpl *darg = 0;
65287   float result;
65288
65289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65290   arg2 = (float)jarg2;
65291   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65292   if (!darg) {
65293     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65294     return 0;
65295   }
65296   {
65297     try {
65298       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65299     } catch (std::out_of_range& e) {
65300       {
65301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65302       };
65303     } catch (std::exception& e) {
65304       {
65305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65306       };
65307     } catch (Dali::DaliException e) {
65308       {
65309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65310       };
65311     } catch (...) {
65312       {
65313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65314       };
65315     }
65316   }
65317
65318   jresult = result;
65319   return jresult;
65320 }
65321
65322
65323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65324   float jresult ;
65325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65326   float arg2 ;
65327   SwigDirector_ViewImpl *darg = 0;
65328   float result;
65329
65330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65331   arg2 = (float)jarg2;
65332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65333   if (!darg) {
65334     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65335     return 0;
65336   }
65337   {
65338     try {
65339       result = (float)(darg)->GetWidthForHeight(arg2);
65340     } catch (std::out_of_range& e) {
65341       {
65342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65343       };
65344     } catch (std::exception& e) {
65345       {
65346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65347       };
65348     } catch (Dali::DaliException e) {
65349       {
65350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65351       };
65352     } catch (...) {
65353       {
65354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65355       };
65356     }
65357   }
65358
65359   jresult = result;
65360   return jresult;
65361 }
65362
65363
65364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65365   float jresult ;
65366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65367   float arg2 ;
65368   SwigDirector_ViewImpl *darg = 0;
65369   float result;
65370
65371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65372   arg2 = (float)jarg2;
65373   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65374   if (!darg) {
65375     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65376     return 0;
65377   }
65378   {
65379     try {
65380       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65381     } catch (std::out_of_range& e) {
65382       {
65383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65384       };
65385     } catch (std::exception& e) {
65386       {
65387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65388       };
65389     } catch (Dali::DaliException e) {
65390       {
65391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65392       };
65393     } catch (...) {
65394       {
65395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65396       };
65397     }
65398   }
65399
65400   jresult = result;
65401   return jresult;
65402 }
65403
65404
65405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65406   unsigned int jresult ;
65407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65408   Dali::Dimension::Type arg2 ;
65409   SwigDirector_ViewImpl *darg = 0;
65410   bool result;
65411
65412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65413   arg2 = (Dali::Dimension::Type)jarg2;
65414   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65415   if (!darg) {
65416     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65417     return 0;
65418   }
65419   {
65420     try {
65421       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65422     } catch (std::out_of_range& e) {
65423       {
65424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65425       };
65426     } catch (std::exception& e) {
65427       {
65428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65429       };
65430     } catch (Dali::DaliException e) {
65431       {
65432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65433       };
65434     } catch (...) {
65435       {
65436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65437       };
65438     }
65439   }
65440
65441   jresult = result;
65442   return jresult;
65443 }
65444
65445
65446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65447   unsigned int jresult ;
65448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65449   Dali::Dimension::Type arg2 ;
65450   SwigDirector_ViewImpl *darg = 0;
65451   bool result;
65452
65453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65454   arg2 = (Dali::Dimension::Type)jarg2;
65455   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65456   if (!darg) {
65457     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65458     return 0;
65459   }
65460   {
65461     try {
65462       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65463     } catch (std::out_of_range& e) {
65464       {
65465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65466       };
65467     } catch (std::exception& e) {
65468       {
65469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65470       };
65471     } catch (Dali::DaliException e) {
65472       {
65473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65474       };
65475     } catch (...) {
65476       {
65477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65478       };
65479     }
65480   }
65481
65482   jresult = result;
65483   return jresult;
65484 }
65485
65486
65487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65488   unsigned int jresult ;
65489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65490   SwigDirector_ViewImpl *darg = 0;
65491   bool result;
65492
65493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65494   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65495   if (!darg) {
65496     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65497     return 0;
65498   }
65499   {
65500     try {
65501       result = (bool)(darg)->RelayoutDependentOnChildren();
65502     } catch (std::out_of_range& e) {
65503       {
65504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65505       };
65506     } catch (std::exception& e) {
65507       {
65508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65509       };
65510     } catch (Dali::DaliException e) {
65511       {
65512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65513       };
65514     } catch (...) {
65515       {
65516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65517       };
65518     }
65519   }
65520
65521   jresult = result;
65522   return jresult;
65523 }
65524
65525
65526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65527   unsigned int jresult ;
65528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65529   SwigDirector_ViewImpl *darg = 0;
65530   bool result;
65531
65532   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65533   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65534   if (!darg) {
65535     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65536     return 0;
65537   }
65538   {
65539     try {
65540       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65541     } catch (std::out_of_range& e) {
65542       {
65543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65544       };
65545     } catch (std::exception& e) {
65546       {
65547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65548       };
65549     } catch (Dali::DaliException e) {
65550       {
65551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65552       };
65553     } catch (...) {
65554       {
65555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65556       };
65557     }
65558   }
65559
65560   jresult = result;
65561   return jresult;
65562 }
65563
65564
65565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65567   Dali::Dimension::Type arg2 ;
65568   SwigDirector_ViewImpl *darg = 0;
65569
65570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65571   arg2 = (Dali::Dimension::Type)jarg2;
65572   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65573   if (!darg) {
65574     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65575     return;
65576   }
65577   {
65578     try {
65579       (darg)->OnCalculateRelayoutSize(arg2);
65580     } catch (std::out_of_range& e) {
65581       {
65582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65583       };
65584     } catch (std::exception& e) {
65585       {
65586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65587       };
65588     } catch (Dali::DaliException e) {
65589       {
65590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65591       };
65592     } catch (...) {
65593       {
65594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65595       };
65596     }
65597   }
65598
65599 }
65600
65601
65602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65604   Dali::Dimension::Type arg2 ;
65605   SwigDirector_ViewImpl *darg = 0;
65606
65607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65608   arg2 = (Dali::Dimension::Type)jarg2;
65609   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65610   if (!darg) {
65611     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65612     return;
65613   }
65614   {
65615     try {
65616       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65617     } catch (std::out_of_range& e) {
65618       {
65619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65620       };
65621     } catch (std::exception& e) {
65622       {
65623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65624       };
65625     } catch (Dali::DaliException e) {
65626       {
65627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65628       };
65629     } catch (...) {
65630       {
65631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65632       };
65633     }
65634   }
65635
65636 }
65637
65638
65639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65641   float arg2 ;
65642   Dali::Dimension::Type arg3 ;
65643   SwigDirector_ViewImpl *darg = 0;
65644
65645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65646   arg2 = (float)jarg2;
65647   arg3 = (Dali::Dimension::Type)jarg3;
65648   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65649   if (!darg) {
65650     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65651     return;
65652   }
65653   {
65654     try {
65655       (darg)->OnLayoutNegotiated(arg2,arg3);
65656     } catch (std::out_of_range& e) {
65657       {
65658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65659       };
65660     } catch (std::exception& e) {
65661       {
65662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65663       };
65664     } catch (Dali::DaliException e) {
65665       {
65666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65667       };
65668     } catch (...) {
65669       {
65670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65671       };
65672     }
65673   }
65674
65675 }
65676
65677
65678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65680   float arg2 ;
65681   Dali::Dimension::Type arg3 ;
65682   SwigDirector_ViewImpl *darg = 0;
65683
65684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65685   arg2 = (float)jarg2;
65686   arg3 = (Dali::Dimension::Type)jarg3;
65687   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65688   if (!darg) {
65689     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65690     return;
65691   }
65692   {
65693     try {
65694       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65695     } catch (std::out_of_range& e) {
65696       {
65697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65698       };
65699     } catch (std::exception& e) {
65700       {
65701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65702       };
65703     } catch (Dali::DaliException e) {
65704       {
65705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65706       };
65707     } catch (...) {
65708       {
65709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65710       };
65711     }
65712   }
65713
65714 }
65715
65716
65717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65719
65720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65721   {
65722     try {
65723       (arg1)->OnInitialize();
65724     } catch (std::out_of_range& e) {
65725       {
65726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65727       };
65728     } catch (std::exception& e) {
65729       {
65730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65731       };
65732     } catch (Dali::DaliException e) {
65733       {
65734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65735       };
65736     } catch (...) {
65737       {
65738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65739       };
65740     }
65741   }
65742
65743 }
65744
65745
65746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65748
65749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65750   {
65751     try {
65752       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65753     } catch (std::out_of_range& e) {
65754       {
65755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65756       };
65757     } catch (std::exception& e) {
65758       {
65759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65760       };
65761     } catch (Dali::DaliException e) {
65762       {
65763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65764       };
65765     } catch (...) {
65766       {
65767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65768       };
65769     }
65770   }
65771
65772 }
65773
65774
65775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65777   Dali::Actor *arg2 = 0 ;
65778
65779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65780   arg2 = (Dali::Actor *)jarg2;
65781   if (!arg2) {
65782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65783     return ;
65784   }
65785   {
65786     try {
65787       (arg1)->OnControlChildAdd(*arg2);
65788     } catch (std::out_of_range& e) {
65789       {
65790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65791       };
65792     } catch (std::exception& e) {
65793       {
65794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65795       };
65796     } catch (Dali::DaliException e) {
65797       {
65798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65799       };
65800     } catch (...) {
65801       {
65802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65803       };
65804     }
65805   }
65806
65807 }
65808
65809
65810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65812   Dali::Actor *arg2 = 0 ;
65813
65814   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65815   arg2 = (Dali::Actor *)jarg2;
65816   if (!arg2) {
65817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65818     return ;
65819   }
65820   {
65821     try {
65822       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65823     } catch (std::out_of_range& e) {
65824       {
65825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65826       };
65827     } catch (std::exception& e) {
65828       {
65829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65830       };
65831     } catch (Dali::DaliException e) {
65832       {
65833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65834       };
65835     } catch (...) {
65836       {
65837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65838       };
65839     }
65840   }
65841
65842 }
65843
65844
65845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65847   Dali::Actor *arg2 = 0 ;
65848
65849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65850   arg2 = (Dali::Actor *)jarg2;
65851   if (!arg2) {
65852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65853     return ;
65854   }
65855   {
65856     try {
65857       (arg1)->OnControlChildRemove(*arg2);
65858     } catch (std::out_of_range& e) {
65859       {
65860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65861       };
65862     } catch (std::exception& e) {
65863       {
65864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65865       };
65866     } catch (Dali::DaliException e) {
65867       {
65868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65869       };
65870     } catch (...) {
65871       {
65872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65873       };
65874     }
65875   }
65876
65877 }
65878
65879
65880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65882   Dali::Actor *arg2 = 0 ;
65883
65884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65885   arg2 = (Dali::Actor *)jarg2;
65886   if (!arg2) {
65887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65888     return ;
65889   }
65890   {
65891     try {
65892       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65893     } catch (std::out_of_range& e) {
65894       {
65895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65896       };
65897     } catch (std::exception& e) {
65898       {
65899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65900       };
65901     } catch (Dali::DaliException e) {
65902       {
65903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65904       };
65905     } catch (...) {
65906       {
65907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65908       };
65909     }
65910   }
65911
65912 }
65913
65914
65915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65917   Dali::Toolkit::StyleManager arg2 ;
65918   Dali::StyleChange::Type arg3 ;
65919   Dali::Toolkit::StyleManager *argp2 ;
65920
65921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65922   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65923   if (!argp2) {
65924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65925     return ;
65926   }
65927   arg2 = *argp2;
65928   arg3 = (Dali::StyleChange::Type)jarg3;
65929   {
65930     try {
65931       (arg1)->OnStyleChange(arg2,arg3);
65932     } catch (std::out_of_range& e) {
65933       {
65934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65935       };
65936     } catch (std::exception& e) {
65937       {
65938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65939       };
65940     } catch (Dali::DaliException e) {
65941       {
65942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65943       };
65944     } catch (...) {
65945       {
65946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65947       };
65948     }
65949   }
65950
65951 }
65952
65953
65954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65956   Dali::Toolkit::StyleManager arg2 ;
65957   Dali::StyleChange::Type arg3 ;
65958   Dali::Toolkit::StyleManager *argp2 ;
65959
65960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65961   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65962   if (!argp2) {
65963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65964     return ;
65965   }
65966   arg2 = *argp2;
65967   arg3 = (Dali::StyleChange::Type)jarg3;
65968   {
65969     try {
65970       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65971     } catch (std::out_of_range& e) {
65972       {
65973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65974       };
65975     } catch (std::exception& e) {
65976       {
65977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65978       };
65979     } catch (Dali::DaliException e) {
65980       {
65981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65982       };
65983     } catch (...) {
65984       {
65985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65986       };
65987     }
65988   }
65989
65990 }
65991
65992
65993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65994   unsigned int jresult ;
65995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65996   bool result;
65997
65998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65999   {
66000     try {
66001       result = (bool)(arg1)->OnAccessibilityActivated();
66002     } catch (std::out_of_range& e) {
66003       {
66004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66005       };
66006     } catch (std::exception& e) {
66007       {
66008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66009       };
66010     } catch (Dali::DaliException e) {
66011       {
66012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66013       };
66014     } catch (...) {
66015       {
66016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66017       };
66018     }
66019   }
66020
66021   jresult = result;
66022   return jresult;
66023 }
66024
66025
66026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66027   unsigned int jresult ;
66028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66029   bool result;
66030
66031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66032   {
66033     try {
66034       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66035     } catch (std::out_of_range& e) {
66036       {
66037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66038       };
66039     } catch (std::exception& e) {
66040       {
66041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66042       };
66043     } catch (Dali::DaliException e) {
66044       {
66045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66046       };
66047     } catch (...) {
66048       {
66049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66050       };
66051     }
66052   }
66053
66054   jresult = result;
66055   return jresult;
66056 }
66057
66058
66059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66060   unsigned int jresult ;
66061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66062   Dali::PanGesture arg2 ;
66063   Dali::PanGesture *argp2 ;
66064   bool result;
66065
66066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66067   argp2 = (Dali::PanGesture *)jarg2;
66068   if (!argp2) {
66069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66070     return 0;
66071   }
66072   arg2 = *argp2;
66073   {
66074     try {
66075       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66076     } catch (std::out_of_range& e) {
66077       {
66078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66079       };
66080     } catch (std::exception& e) {
66081       {
66082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66083       };
66084     } catch (Dali::DaliException e) {
66085       {
66086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66087       };
66088     } catch (...) {
66089       {
66090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66091       };
66092     }
66093   }
66094
66095   jresult = result;
66096   return jresult;
66097 }
66098
66099
66100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66101   unsigned int jresult ;
66102   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66103   Dali::PanGesture arg2 ;
66104   Dali::PanGesture *argp2 ;
66105   bool result;
66106
66107   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66108   argp2 = (Dali::PanGesture *)jarg2;
66109   if (!argp2) {
66110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66111     return 0;
66112   }
66113   arg2 = *argp2;
66114   {
66115     try {
66116       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66117     } catch (std::out_of_range& e) {
66118       {
66119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66120       };
66121     } catch (std::exception& e) {
66122       {
66123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66124       };
66125     } catch (Dali::DaliException e) {
66126       {
66127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66128       };
66129     } catch (...) {
66130       {
66131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66132       };
66133     }
66134   }
66135
66136   jresult = result;
66137   return jresult;
66138 }
66139
66140
66141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66142   unsigned int jresult ;
66143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66144   Dali::TouchEvent *arg2 = 0 ;
66145   bool result;
66146
66147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66148   arg2 = (Dali::TouchEvent *)jarg2;
66149   if (!arg2) {
66150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66151     return 0;
66152   }
66153   {
66154     try {
66155       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66156     } catch (std::out_of_range& e) {
66157       {
66158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66159       };
66160     } catch (std::exception& e) {
66161       {
66162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66163       };
66164     } catch (Dali::DaliException e) {
66165       {
66166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66167       };
66168     } catch (...) {
66169       {
66170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66171       };
66172     }
66173   }
66174
66175   jresult = result;
66176   return jresult;
66177 }
66178
66179
66180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66181   unsigned int jresult ;
66182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66183   Dali::TouchEvent *arg2 = 0 ;
66184   bool result;
66185
66186   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66187   arg2 = (Dali::TouchEvent *)jarg2;
66188   if (!arg2) {
66189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66190     return 0;
66191   }
66192   {
66193     try {
66194       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66195     } catch (std::out_of_range& e) {
66196       {
66197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66198       };
66199     } catch (std::exception& e) {
66200       {
66201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66202       };
66203     } catch (Dali::DaliException e) {
66204       {
66205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66206       };
66207     } catch (...) {
66208       {
66209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66210       };
66211     }
66212   }
66213
66214   jresult = result;
66215   return jresult;
66216 }
66217
66218
66219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66220   unsigned int jresult ;
66221   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66222   bool arg2 ;
66223   bool result;
66224
66225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66226   arg2 = jarg2 ? true : false;
66227   {
66228     try {
66229       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66237       };
66238     } catch (Dali::DaliException e) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66241       };
66242     } catch (...) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66245       };
66246     }
66247   }
66248
66249   jresult = result;
66250   return jresult;
66251 }
66252
66253
66254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66255   unsigned int jresult ;
66256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66257   bool arg2 ;
66258   bool result;
66259
66260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66261   arg2 = jarg2 ? true : false;
66262   {
66263     try {
66264       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66265     } catch (std::out_of_range& e) {
66266       {
66267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66268       };
66269     } catch (std::exception& e) {
66270       {
66271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66272       };
66273     } catch (Dali::DaliException e) {
66274       {
66275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66276       };
66277     } catch (...) {
66278       {
66279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66280       };
66281     }
66282   }
66283
66284   jresult = result;
66285   return jresult;
66286 }
66287
66288
66289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66290   unsigned int jresult ;
66291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66292   bool result;
66293
66294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66295   {
66296     try {
66297       result = (bool)(arg1)->OnAccessibilityZoom();
66298     } catch (std::out_of_range& e) {
66299       {
66300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66301       };
66302     } catch (std::exception& e) {
66303       {
66304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66305       };
66306     } catch (Dali::DaliException e) {
66307       {
66308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66309       };
66310     } catch (...) {
66311       {
66312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66313       };
66314     }
66315   }
66316
66317   jresult = result;
66318   return jresult;
66319 }
66320
66321
66322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66323   unsigned int jresult ;
66324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66325   bool result;
66326
66327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66328   {
66329     try {
66330       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66331     } catch (std::out_of_range& e) {
66332       {
66333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66334       };
66335     } catch (std::exception& e) {
66336       {
66337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66338       };
66339     } catch (Dali::DaliException e) {
66340       {
66341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66342       };
66343     } catch (...) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66346       };
66347     }
66348   }
66349
66350   jresult = result;
66351   return jresult;
66352 }
66353
66354
66355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66357
66358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66359   {
66360     try {
66361       (arg1)->OnKeyInputFocusGained();
66362     } catch (std::out_of_range& e) {
66363       {
66364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66365       };
66366     } catch (std::exception& e) {
66367       {
66368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66369       };
66370     } catch (Dali::DaliException e) {
66371       {
66372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66373       };
66374     } catch (...) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66377       };
66378     }
66379   }
66380
66381 }
66382
66383
66384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66386
66387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66388   {
66389     try {
66390       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66391     } catch (std::out_of_range& e) {
66392       {
66393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66394       };
66395     } catch (std::exception& e) {
66396       {
66397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66398       };
66399     } catch (Dali::DaliException e) {
66400       {
66401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66402       };
66403     } catch (...) {
66404       {
66405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66406       };
66407     }
66408   }
66409
66410 }
66411
66412
66413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66415
66416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66417   {
66418     try {
66419       (arg1)->OnKeyInputFocusLost();
66420     } catch (std::out_of_range& e) {
66421       {
66422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66423       };
66424     } catch (std::exception& e) {
66425       {
66426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66427       };
66428     } catch (Dali::DaliException e) {
66429       {
66430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66431       };
66432     } catch (...) {
66433       {
66434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66435       };
66436     }
66437   }
66438
66439 }
66440
66441
66442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66444
66445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66446   {
66447     try {
66448       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66449     } catch (std::out_of_range& e) {
66450       {
66451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66452       };
66453     } catch (std::exception& e) {
66454       {
66455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66456       };
66457     } catch (Dali::DaliException e) {
66458       {
66459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66460       };
66461     } catch (...) {
66462       {
66463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66464       };
66465     }
66466   }
66467
66468 }
66469
66470
66471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66472   void * jresult ;
66473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66474   Dali::Actor arg2 ;
66475   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66476   bool arg4 ;
66477   Dali::Actor *argp2 ;
66478   Dali::Actor result;
66479
66480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66481   argp2 = (Dali::Actor *)jarg2;
66482   if (!argp2) {
66483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66484     return 0;
66485   }
66486   arg2 = *argp2;
66487   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66488   arg4 = jarg4 ? true : false;
66489   {
66490     try {
66491       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66492     } catch (std::out_of_range& e) {
66493       {
66494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66495       };
66496     } catch (std::exception& e) {
66497       {
66498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66499       };
66500     } catch (Dali::DaliException e) {
66501       {
66502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66503       };
66504     } catch (...) {
66505       {
66506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66507       };
66508     }
66509   }
66510
66511   jresult = new Dali::Actor((const Dali::Actor &)result);
66512   return jresult;
66513 }
66514
66515
66516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66517   void * jresult ;
66518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66519   Dali::Actor arg2 ;
66520   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66521   bool arg4 ;
66522   Dali::Actor *argp2 ;
66523   Dali::Actor result;
66524
66525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66526   argp2 = (Dali::Actor *)jarg2;
66527   if (!argp2) {
66528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66529     return 0;
66530   }
66531   arg2 = *argp2;
66532   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66533   arg4 = jarg4 ? true : false;
66534   {
66535     try {
66536       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66537     } catch (std::out_of_range& e) {
66538       {
66539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66540       };
66541     } catch (std::exception& e) {
66542       {
66543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66544       };
66545     } catch (Dali::DaliException e) {
66546       {
66547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66548       };
66549     } catch (...) {
66550       {
66551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66552       };
66553     }
66554   }
66555
66556   jresult = new Dali::Actor((const Dali::Actor &)result);
66557   return jresult;
66558 }
66559
66560
66561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66563   Dali::Actor arg2 ;
66564   Dali::Actor *argp2 ;
66565
66566   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66567   argp2 = (Dali::Actor *)jarg2;
66568   if (!argp2) {
66569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66570     return ;
66571   }
66572   arg2 = *argp2;
66573   {
66574     try {
66575       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66576     } catch (std::out_of_range& e) {
66577       {
66578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66579       };
66580     } catch (std::exception& e) {
66581       {
66582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66583       };
66584     } catch (Dali::DaliException e) {
66585       {
66586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66587       };
66588     } catch (...) {
66589       {
66590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66591       };
66592     }
66593   }
66594
66595 }
66596
66597
66598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66600   Dali::Actor arg2 ;
66601   Dali::Actor *argp2 ;
66602
66603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66604   argp2 = (Dali::Actor *)jarg2;
66605   if (!argp2) {
66606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66607     return ;
66608   }
66609   arg2 = *argp2;
66610   {
66611     try {
66612       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66613     } catch (std::out_of_range& e) {
66614       {
66615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66616       };
66617     } catch (std::exception& e) {
66618       {
66619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66620       };
66621     } catch (Dali::DaliException e) {
66622       {
66623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66624       };
66625     } catch (...) {
66626       {
66627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66628       };
66629     }
66630   }
66631
66632 }
66633
66634
66635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66636   unsigned int jresult ;
66637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66638   bool result;
66639
66640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66641   {
66642     try {
66643       result = (bool)(arg1)->OnKeyboardEnter();
66644     } catch (std::out_of_range& e) {
66645       {
66646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66647       };
66648     } catch (std::exception& e) {
66649       {
66650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66651       };
66652     } catch (Dali::DaliException e) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66655       };
66656     } catch (...) {
66657       {
66658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66659       };
66660     }
66661   }
66662
66663   jresult = result;
66664   return jresult;
66665 }
66666
66667
66668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66669   unsigned int jresult ;
66670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66671   bool result;
66672
66673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66674   {
66675     try {
66676       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66677     } catch (std::out_of_range& e) {
66678       {
66679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66680       };
66681     } catch (std::exception& e) {
66682       {
66683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66684       };
66685     } catch (Dali::DaliException e) {
66686       {
66687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66688       };
66689     } catch (...) {
66690       {
66691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66692       };
66693     }
66694   }
66695
66696   jresult = result;
66697   return jresult;
66698 }
66699
66700
66701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66703   Dali::PinchGesture *arg2 = 0 ;
66704
66705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66706   arg2 = (Dali::PinchGesture *)jarg2;
66707   if (!arg2) {
66708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66709     return ;
66710   }
66711   {
66712     try {
66713       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66721       };
66722     } catch (Dali::DaliException e) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66725       };
66726     } catch (...) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66729       };
66730     }
66731   }
66732
66733 }
66734
66735
66736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66738   Dali::PinchGesture *arg2 = 0 ;
66739
66740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66741   arg2 = (Dali::PinchGesture *)jarg2;
66742   if (!arg2) {
66743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66744     return ;
66745   }
66746   {
66747     try {
66748       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66749     } catch (std::out_of_range& e) {
66750       {
66751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66752       };
66753     } catch (std::exception& e) {
66754       {
66755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66756       };
66757     } catch (Dali::DaliException e) {
66758       {
66759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66760       };
66761     } catch (...) {
66762       {
66763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66764       };
66765     }
66766   }
66767
66768 }
66769
66770
66771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66773   Dali::PanGesture *arg2 = 0 ;
66774
66775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66776   arg2 = (Dali::PanGesture *)jarg2;
66777   if (!arg2) {
66778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66779     return ;
66780   }
66781   {
66782     try {
66783       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66784     } catch (std::out_of_range& e) {
66785       {
66786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66787       };
66788     } catch (std::exception& e) {
66789       {
66790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66791       };
66792     } catch (Dali::DaliException e) {
66793       {
66794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66795       };
66796     } catch (...) {
66797       {
66798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66799       };
66800     }
66801   }
66802
66803 }
66804
66805
66806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66808   Dali::PanGesture *arg2 = 0 ;
66809
66810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66811   arg2 = (Dali::PanGesture *)jarg2;
66812   if (!arg2) {
66813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66814     return ;
66815   }
66816   {
66817     try {
66818       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66819     } catch (std::out_of_range& e) {
66820       {
66821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66822       };
66823     } catch (std::exception& e) {
66824       {
66825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66826       };
66827     } catch (Dali::DaliException e) {
66828       {
66829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66830       };
66831     } catch (...) {
66832       {
66833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66834       };
66835     }
66836   }
66837
66838 }
66839
66840
66841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66843   Dali::TapGesture *arg2 = 0 ;
66844
66845   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66846   arg2 = (Dali::TapGesture *)jarg2;
66847   if (!arg2) {
66848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66849     return ;
66850   }
66851   {
66852     try {
66853       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66854     } catch (std::out_of_range& e) {
66855       {
66856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66857       };
66858     } catch (std::exception& e) {
66859       {
66860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66861       };
66862     } catch (Dali::DaliException e) {
66863       {
66864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66865       };
66866     } catch (...) {
66867       {
66868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66869       };
66870     }
66871   }
66872
66873 }
66874
66875
66876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66878   Dali::TapGesture *arg2 = 0 ;
66879
66880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66881   arg2 = (Dali::TapGesture *)jarg2;
66882   if (!arg2) {
66883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66884     return ;
66885   }
66886   {
66887     try {
66888       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66889     } catch (std::out_of_range& e) {
66890       {
66891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66892       };
66893     } catch (std::exception& e) {
66894       {
66895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66896       };
66897     } catch (Dali::DaliException e) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66900       };
66901     } catch (...) {
66902       {
66903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66904       };
66905     }
66906   }
66907
66908 }
66909
66910
66911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66913   Dali::LongPressGesture *arg2 = 0 ;
66914
66915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66916   arg2 = (Dali::LongPressGesture *)jarg2;
66917   if (!arg2) {
66918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66919     return ;
66920   }
66921   {
66922     try {
66923       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66924     } catch (std::out_of_range& e) {
66925       {
66926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66927       };
66928     } catch (std::exception& e) {
66929       {
66930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66931       };
66932     } catch (Dali::DaliException e) {
66933       {
66934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66935       };
66936     } catch (...) {
66937       {
66938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66939       };
66940     }
66941   }
66942
66943 }
66944
66945
66946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66948   Dali::LongPressGesture *arg2 = 0 ;
66949
66950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66951   arg2 = (Dali::LongPressGesture *)jarg2;
66952   if (!arg2) {
66953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66954     return ;
66955   }
66956   {
66957     try {
66958       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66959     } catch (std::out_of_range& e) {
66960       {
66961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66962       };
66963     } catch (std::exception& e) {
66964       {
66965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66966       };
66967     } catch (Dali::DaliException e) {
66968       {
66969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66970       };
66971     } catch (...) {
66972       {
66973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66974       };
66975     }
66976   }
66977
66978 }
66979
66980
66981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66983   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66984   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66985
66986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66987   arg2 = (Dali::SlotObserver *)jarg2;
66988   arg3 = (Dali::CallbackBase *)jarg3;
66989   {
66990     try {
66991       (arg1)->SignalConnected(arg2,arg3);
66992     } catch (std::out_of_range& e) {
66993       {
66994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66995       };
66996     } catch (std::exception& e) {
66997       {
66998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66999       };
67000     } catch (Dali::DaliException e) {
67001       {
67002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67003       };
67004     } catch (...) {
67005       {
67006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67007       };
67008     }
67009   }
67010
67011 }
67012
67013
67014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67016   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67017   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67018
67019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67020   arg2 = (Dali::SlotObserver *)jarg2;
67021   arg3 = (Dali::CallbackBase *)jarg3;
67022   {
67023     try {
67024       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67025     } catch (std::out_of_range& e) {
67026       {
67027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67028       };
67029     } catch (std::exception& e) {
67030       {
67031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67032       };
67033     } catch (Dali::DaliException e) {
67034       {
67035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67036       };
67037     } catch (...) {
67038       {
67039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67040       };
67041     }
67042   }
67043
67044 }
67045
67046
67047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67049   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67050   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67051
67052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67053   arg2 = (Dali::SlotObserver *)jarg2;
67054   arg3 = (Dali::CallbackBase *)jarg3;
67055   {
67056     try {
67057       (arg1)->SignalDisconnected(arg2,arg3);
67058     } catch (std::out_of_range& e) {
67059       {
67060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67061       };
67062     } catch (std::exception& e) {
67063       {
67064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67065       };
67066     } catch (Dali::DaliException e) {
67067       {
67068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67069       };
67070     } catch (...) {
67071       {
67072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67073       };
67074     }
67075   }
67076
67077 }
67078
67079
67080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67082   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67083   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67084
67085   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67086   arg2 = (Dali::SlotObserver *)jarg2;
67087   arg3 = (Dali::CallbackBase *)jarg3;
67088   {
67089     try {
67090       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67091     } catch (std::out_of_range& e) {
67092       {
67093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67094       };
67095     } catch (std::exception& e) {
67096       {
67097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67098       };
67099     } catch (Dali::DaliException e) {
67100       {
67101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67102       };
67103     } catch (...) {
67104       {
67105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67106       };
67107     }
67108   }
67109
67110 }
67111
67112
67113 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) {
67114   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67115   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67116   if (director) {
67117     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);
67118   }
67119 }
67120
67121
67122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67123   void * jresult ;
67124   Dali::Toolkit::Control *arg1 = 0 ;
67125   Dali::Toolkit::Internal::Control *result = 0 ;
67126
67127   arg1 = (Dali::Toolkit::Control *)jarg1;
67128   if (!arg1) {
67129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67130     return 0;
67131   }
67132   {
67133     try {
67134       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67135     } catch (std::out_of_range& e) {
67136       {
67137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67138       };
67139     } catch (std::exception& e) {
67140       {
67141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67142       };
67143     } catch (Dali::DaliException e) {
67144       {
67145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67146       };
67147     } catch (...) {
67148       {
67149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67150       };
67151     }
67152   }
67153
67154   jresult = (void *)result;
67155   return jresult;
67156 }
67157
67158
67159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67160   int jresult ;
67161   int result;
67162
67163   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67164   jresult = (int)result;
67165   return jresult;
67166 }
67167
67168
67169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67170   int jresult ;
67171   int result;
67172
67173   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67174   jresult = (int)result;
67175   return jresult;
67176 }
67177
67178
67179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67180   int jresult ;
67181   int result;
67182
67183   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67184   jresult = (int)result;
67185   return jresult;
67186 }
67187
67188
67189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67190   int jresult ;
67191   int result;
67192
67193   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67194   jresult = (int)result;
67195   return jresult;
67196 }
67197
67198
67199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67200   int jresult ;
67201   int result;
67202
67203   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67204   jresult = (int)result;
67205   return jresult;
67206 }
67207
67208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67209   int jresult ;
67210   int result;
67211
67212   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67213   jresult = (int)result;
67214   return jresult;
67215 }
67216
67217
67218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67219   int jresult ;
67220   int result;
67221
67222   result = (int)Dali::Toolkit::Control::Property::PADDING;
67223   jresult = (int)result;
67224   return jresult;
67225 }
67226
67227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67228   void * jresult ;
67229   Dali::Toolkit::Control::Property *result = 0 ;
67230
67231   {
67232     try {
67233       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67234     } catch (std::out_of_range& e) {
67235       {
67236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67237       };
67238     } catch (std::exception& e) {
67239       {
67240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67241       };
67242     } catch (Dali::DaliException e) {
67243       {
67244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67245       };
67246     } catch (...) {
67247       {
67248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67249       };
67250     }
67251   }
67252
67253   jresult = (void *)result;
67254   return jresult;
67255 }
67256
67257
67258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67259   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67260
67261   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67262   {
67263     try {
67264       delete arg1;
67265     } catch (std::out_of_range& e) {
67266       {
67267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67268       };
67269     } catch (std::exception& e) {
67270       {
67271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67272       };
67273     } catch (Dali::DaliException e) {
67274       {
67275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67276       };
67277     } catch (...) {
67278       {
67279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67280       };
67281     }
67282   }
67283
67284 }
67285
67286
67287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67288   void * jresult ;
67289   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67290
67291   {
67292     try {
67293       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67294     } catch (std::out_of_range& e) {
67295       {
67296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67297       };
67298     } catch (std::exception& e) {
67299       {
67300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67301       };
67302     } catch (Dali::DaliException e) {
67303       {
67304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67305       };
67306     } catch (...) {
67307       {
67308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67309       };
67310     }
67311   }
67312
67313   jresult = (void *)result;
67314   return jresult;
67315 }
67316
67317
67318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67319   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67320
67321   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67322   {
67323     try {
67324       delete arg1;
67325     } catch (std::out_of_range& e) {
67326       {
67327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67328       };
67329     } catch (std::exception& e) {
67330       {
67331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67332       };
67333     } catch (Dali::DaliException e) {
67334       {
67335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67336       };
67337     } catch (...) {
67338       {
67339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67340       };
67341     }
67342   }
67343
67344 }
67345
67346
67347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67348   void * jresult ;
67349   Dali::Toolkit::Control result;
67350
67351   {
67352     try {
67353       result = Dali::Toolkit::Control::New();
67354     } catch (std::out_of_range& e) {
67355       {
67356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67357       };
67358     } catch (std::exception& e) {
67359       {
67360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67361       };
67362     } catch (Dali::DaliException e) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67365       };
67366     } catch (...) {
67367       {
67368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67369       };
67370     }
67371   }
67372
67373   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67374   return jresult;
67375 }
67376
67377
67378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67379   void * jresult ;
67380   Dali::Toolkit::Control *result = 0 ;
67381
67382   {
67383     try {
67384       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67385     } catch (std::out_of_range& e) {
67386       {
67387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67388       };
67389     } catch (std::exception& e) {
67390       {
67391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67392       };
67393     } catch (Dali::DaliException e) {
67394       {
67395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67396       };
67397     } catch (...) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67400       };
67401     }
67402   }
67403
67404   jresult = (void *)result;
67405   return jresult;
67406 }
67407
67408
67409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67410   void * jresult ;
67411   Dali::Toolkit::Control *arg1 = 0 ;
67412   Dali::Toolkit::Control *result = 0 ;
67413
67414   arg1 = (Dali::Toolkit::Control *)jarg1;
67415   if (!arg1) {
67416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67417     return 0;
67418   }
67419   {
67420     try {
67421       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67422     } catch (std::out_of_range& e) {
67423       {
67424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67425       };
67426     } catch (std::exception& e) {
67427       {
67428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67429       };
67430     } catch (Dali::DaliException e) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67433       };
67434     } catch (...) {
67435       {
67436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67437       };
67438     }
67439   }
67440
67441   jresult = (void *)result;
67442   return jresult;
67443 }
67444
67445
67446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67447   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67448
67449   arg1 = (Dali::Toolkit::Control *)jarg1;
67450   {
67451     try {
67452       delete arg1;
67453     } catch (std::out_of_range& e) {
67454       {
67455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67456       };
67457     } catch (std::exception& e) {
67458       {
67459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67460       };
67461     } catch (Dali::DaliException e) {
67462       {
67463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67464       };
67465     } catch (...) {
67466       {
67467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67468       };
67469     }
67470   }
67471
67472 }
67473
67474
67475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67476   void * jresult ;
67477   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67478   Dali::Toolkit::Control *arg2 = 0 ;
67479   Dali::Toolkit::Control *result = 0 ;
67480
67481   arg1 = (Dali::Toolkit::Control *)jarg1;
67482   arg2 = (Dali::Toolkit::Control *)jarg2;
67483   if (!arg2) {
67484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67485     return 0;
67486   }
67487   {
67488     try {
67489       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67490     } catch (std::out_of_range& e) {
67491       {
67492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67493       };
67494     } catch (std::exception& e) {
67495       {
67496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (Dali::DaliException e) {
67499       {
67500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67501       };
67502     } catch (...) {
67503       {
67504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67505       };
67506     }
67507   }
67508
67509   jresult = (void *)result;
67510   return jresult;
67511 }
67512
67513
67514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67515   void * jresult ;
67516   Dali::BaseHandle arg1 ;
67517   Dali::BaseHandle *argp1 ;
67518   Dali::Toolkit::Control result;
67519
67520   argp1 = (Dali::BaseHandle *)jarg1;
67521   if (!argp1) {
67522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67523     return 0;
67524   }
67525   arg1 = *argp1;
67526   {
67527     try {
67528       result = Dali::Toolkit::Control::DownCast(arg1);
67529     } catch (std::out_of_range& e) {
67530       {
67531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67532       };
67533     } catch (std::exception& e) {
67534       {
67535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67536       };
67537     } catch (Dali::DaliException e) {
67538       {
67539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67540       };
67541     } catch (...) {
67542       {
67543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67544       };
67545     }
67546   }
67547
67548   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67549   return jresult;
67550 }
67551
67552
67553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67554   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67555
67556   arg1 = (Dali::Toolkit::Control *)jarg1;
67557   {
67558     try {
67559       (arg1)->SetKeyInputFocus();
67560     } catch (std::out_of_range& e) {
67561       {
67562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67563       };
67564     } catch (std::exception& e) {
67565       {
67566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67567       };
67568     } catch (Dali::DaliException e) {
67569       {
67570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67571       };
67572     } catch (...) {
67573       {
67574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67575       };
67576     }
67577   }
67578
67579 }
67580
67581
67582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67583   unsigned int jresult ;
67584   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67585   bool result;
67586
67587   arg1 = (Dali::Toolkit::Control *)jarg1;
67588   {
67589     try {
67590       result = (bool)(arg1)->HasKeyInputFocus();
67591     } catch (std::out_of_range& e) {
67592       {
67593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67594       };
67595     } catch (std::exception& e) {
67596       {
67597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67598       };
67599     } catch (Dali::DaliException e) {
67600       {
67601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67602       };
67603     } catch (...) {
67604       {
67605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67606       };
67607     }
67608   }
67609
67610   jresult = result;
67611   return jresult;
67612 }
67613
67614
67615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67616   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67617
67618   arg1 = (Dali::Toolkit::Control *)jarg1;
67619   {
67620     try {
67621       (arg1)->ClearKeyInputFocus();
67622     } catch (std::out_of_range& e) {
67623       {
67624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67625       };
67626     } catch (std::exception& e) {
67627       {
67628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67629       };
67630     } catch (Dali::DaliException e) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67633       };
67634     } catch (...) {
67635       {
67636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67637       };
67638     }
67639   }
67640
67641 }
67642
67643
67644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67645   void * jresult ;
67646   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67647   Dali::PinchGestureDetector result;
67648
67649   arg1 = (Dali::Toolkit::Control *)jarg1;
67650   {
67651     try {
67652       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67653     } catch (std::out_of_range& e) {
67654       {
67655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67656       };
67657     } catch (std::exception& e) {
67658       {
67659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67660       };
67661     } catch (Dali::DaliException e) {
67662       {
67663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67664       };
67665     } catch (...) {
67666       {
67667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67668       };
67669     }
67670   }
67671
67672   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67673   return jresult;
67674 }
67675
67676
67677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67678   void * jresult ;
67679   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67680   Dali::PanGestureDetector result;
67681
67682   arg1 = (Dali::Toolkit::Control *)jarg1;
67683   {
67684     try {
67685       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67686     } catch (std::out_of_range& e) {
67687       {
67688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67689       };
67690     } catch (std::exception& e) {
67691       {
67692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67693       };
67694     } catch (Dali::DaliException e) {
67695       {
67696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67697       };
67698     } catch (...) {
67699       {
67700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67701       };
67702     }
67703   }
67704
67705   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67706   return jresult;
67707 }
67708
67709
67710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67711   void * jresult ;
67712   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67713   Dali::TapGestureDetector result;
67714
67715   arg1 = (Dali::Toolkit::Control *)jarg1;
67716   {
67717     try {
67718       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67719     } catch (std::out_of_range& e) {
67720       {
67721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67722       };
67723     } catch (std::exception& e) {
67724       {
67725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67726       };
67727     } catch (Dali::DaliException e) {
67728       {
67729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67730       };
67731     } catch (...) {
67732       {
67733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67734       };
67735     }
67736   }
67737
67738   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67739   return jresult;
67740 }
67741
67742
67743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67744   void * jresult ;
67745   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67746   Dali::LongPressGestureDetector result;
67747
67748   arg1 = (Dali::Toolkit::Control *)jarg1;
67749   {
67750     try {
67751       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67752     } catch (std::out_of_range& e) {
67753       {
67754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67755       };
67756     } catch (std::exception& e) {
67757       {
67758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67759       };
67760     } catch (Dali::DaliException e) {
67761       {
67762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67763       };
67764     } catch (...) {
67765       {
67766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67767       };
67768     }
67769   }
67770
67771   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67772   return jresult;
67773 }
67774
67775
67776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67777   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67778   std::string *arg2 = 0 ;
67779
67780   arg1 = (Dali::Toolkit::Control *)jarg1;
67781   if (!jarg2) {
67782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67783     return ;
67784   }
67785   std::string arg2_str(jarg2);
67786   arg2 = &arg2_str;
67787   {
67788     try {
67789       (arg1)->SetStyleName((std::string const &)*arg2);
67790     } catch (std::out_of_range& e) {
67791       {
67792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67793       };
67794     } catch (std::exception& e) {
67795       {
67796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67797       };
67798     } catch (Dali::DaliException e) {
67799       {
67800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67801       };
67802     } catch (...) {
67803       {
67804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67805       };
67806     }
67807   }
67808
67809
67810   //argout typemap for const std::string&
67811
67812 }
67813
67814
67815 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67816   char * jresult ;
67817   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67818   std::string *result = 0 ;
67819
67820   arg1 = (Dali::Toolkit::Control *)jarg1;
67821   {
67822     try {
67823       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67824     } catch (std::out_of_range& e) {
67825       {
67826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67827       };
67828     } catch (std::exception& e) {
67829       {
67830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67831       };
67832     } catch (Dali::DaliException e) {
67833       {
67834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67835       };
67836     } catch (...) {
67837       {
67838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67839       };
67840     }
67841   }
67842
67843   jresult = SWIG_csharp_string_callback(result->c_str());
67844   return jresult;
67845 }
67846
67847
67848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67849   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67850   Dali::Vector4 *arg2 = 0 ;
67851
67852   arg1 = (Dali::Toolkit::Control *)jarg1;
67853   arg2 = (Dali::Vector4 *)jarg2;
67854   if (!arg2) {
67855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67856     return ;
67857   }
67858   {
67859     try {
67860       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67861     } catch (std::out_of_range& e) {
67862       {
67863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67864       };
67865     } catch (std::exception& e) {
67866       {
67867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67868       };
67869     } catch (Dali::DaliException e) {
67870       {
67871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67872       };
67873     } catch (...) {
67874       {
67875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67876       };
67877     }
67878   }
67879
67880 }
67881
67882
67883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67884   void * jresult ;
67885   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67886   Dali::Vector4 result;
67887
67888   arg1 = (Dali::Toolkit::Control *)jarg1;
67889   {
67890     try {
67891       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67892     } catch (std::out_of_range& e) {
67893       {
67894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67895       };
67896     } catch (std::exception& e) {
67897       {
67898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67899       };
67900     } catch (Dali::DaliException e) {
67901       {
67902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67903       };
67904     } catch (...) {
67905       {
67906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67907       };
67908     }
67909   }
67910
67911   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67912   return jresult;
67913 }
67914
67915
67916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67917   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67918   Dali::Image arg2 ;
67919   Dali::Image *argp2 ;
67920
67921   arg1 = (Dali::Toolkit::Control *)jarg1;
67922   argp2 = (Dali::Image *)jarg2;
67923   if (!argp2) {
67924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67925     return ;
67926   }
67927   arg2 = *argp2;
67928   {
67929     try {
67930       (arg1)->SetBackgroundImage(arg2);
67931     } catch (std::out_of_range& e) {
67932       {
67933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67934       };
67935     } catch (std::exception& e) {
67936       {
67937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67938       };
67939     } catch (Dali::DaliException e) {
67940       {
67941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67942       };
67943     } catch (...) {
67944       {
67945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67946       };
67947     }
67948   }
67949
67950 }
67951
67952
67953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67954   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67955
67956   arg1 = (Dali::Toolkit::Control *)jarg1;
67957   {
67958     try {
67959       (arg1)->ClearBackground();
67960     } catch (std::out_of_range& e) {
67961       {
67962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67963       };
67964     } catch (std::exception& e) {
67965       {
67966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67967       };
67968     } catch (Dali::DaliException e) {
67969       {
67970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67971       };
67972     } catch (...) {
67973       {
67974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67975       };
67976     }
67977   }
67978
67979 }
67980
67981
67982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67983   void * jresult ;
67984   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67985   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67986
67987   arg1 = (Dali::Toolkit::Control *)jarg1;
67988   {
67989     try {
67990       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67991     } catch (std::out_of_range& e) {
67992       {
67993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67994       };
67995     } catch (std::exception& e) {
67996       {
67997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67998       };
67999     } catch (Dali::DaliException e) {
68000       {
68001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68002       };
68003     } catch (...) {
68004       {
68005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68006       };
68007     }
68008   }
68009
68010   jresult = (void *)result;
68011   return jresult;
68012 }
68013
68014
68015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68016   void * jresult ;
68017   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68018   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68019
68020   arg1 = (Dali::Toolkit::Control *)jarg1;
68021   {
68022     try {
68023       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68024     } catch (std::out_of_range& e) {
68025       {
68026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68027       };
68028     } catch (std::exception& e) {
68029       {
68030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68031       };
68032     } catch (Dali::DaliException e) {
68033       {
68034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68035       };
68036     } catch (...) {
68037       {
68038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68039       };
68040     }
68041   }
68042
68043   jresult = (void *)result;
68044   return jresult;
68045 }
68046
68047
68048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68049   void * jresult ;
68050   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68051   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68052
68053   arg1 = (Dali::Toolkit::Control *)jarg1;
68054   {
68055     try {
68056       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68057     } catch (std::out_of_range& e) {
68058       {
68059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68060       };
68061     } catch (std::exception& e) {
68062       {
68063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68064       };
68065     } catch (Dali::DaliException e) {
68066       {
68067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68068       };
68069     } catch (...) {
68070       {
68071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68072       };
68073     }
68074   }
68075
68076   jresult = (void *)result;
68077   return jresult;
68078 }
68079
68080
68081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68082   void * jresult ;
68083   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68084   Dali::Toolkit::Control *result = 0 ;
68085
68086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68087   if (!arg1) {
68088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68089     return 0;
68090   }
68091   {
68092     try {
68093       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68094     } catch (std::out_of_range& e) {
68095       {
68096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68097       };
68098     } catch (std::exception& e) {
68099       {
68100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68101       };
68102     } catch (Dali::DaliException e) {
68103       {
68104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68105       };
68106     } catch (...) {
68107       {
68108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68109       };
68110     }
68111   }
68112
68113   jresult = (void *)result;
68114   return jresult;
68115 }
68116
68117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68118 {
68119   int jresult;
68120   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68121   arg1 = (Dali::Toolkit::Control *)jarg1;
68122
68123   if (!arg1) {
68124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68125     return 0;
68126   }
68127
68128   Dali::Property::Index arg2 = 0 ;
68129   arg2 = (Dali::Property::Index)jarg2;
68130
68131   Toolkit::Visual::ResourceStatus result;
68132   {
68133     try {
68134       result = arg1->GetVisualResourceStatus(arg2);
68135     } catch (std::out_of_range& e) {
68136       {
68137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68138       };
68139     } catch (std::exception& e) {
68140       {
68141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68142       };
68143     } catch (...) {
68144       {
68145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68146       };
68147     }
68148   }
68149   jresult = (int)(result);
68150   return jresult;
68151 }
68152
68153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68154 {
68155   void * jresult;
68156   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68157   arg1 = (Dali::Toolkit::Control *)jarg1;
68158
68159   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68160
68161   Dali::Toolkit::TransitionData *arg2 = 0 ;
68162   Dali::Animation result;
68163
68164   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68165   if (!arg2) {
68166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68167     return 0;
68168   }
68169   {
68170     try {
68171       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68172     } catch (std::out_of_range& e) {
68173       {
68174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68175       };
68176     } catch (std::exception& e) {
68177       {
68178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68179       };
68180     } catch (Dali::DaliException e) {
68181       {
68182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68183       };
68184     } catch (...) {
68185       {
68186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68187       };
68188     }
68189   }
68190
68191   jresult = new Dali::Animation((const Dali::Animation &)result);
68192   return jresult;
68193 }
68194
68195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68196 {
68197   Dali::Toolkit::Control arg1;
68198   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68199
68200   if (!argp1) {
68201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68202   }
68203   arg1 = *argp1;
68204
68205   Dali::Property::Index arg2 = 0 ;
68206   arg2 = (Dali::Property::Index)jarg2;
68207
68208   Dali::Property::Index arg3 = 0 ;
68209   arg3 = (Dali::Property::Index)jarg3;
68210
68211   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
68212
68213   {
68214     try {
68215       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
68216     } catch (std::out_of_range& e) {
68217       {
68218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68219       };
68220     } catch (std::exception& e) {
68221       {
68222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68223       };
68224     } catch (...) {
68225       {
68226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68227       };
68228     }
68229   }
68230
68231
68232 }
68233
68234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68235   void * jresult ;
68236   Dali::Toolkit::Control *arg1 = 0 ;
68237   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68238
68239   arg1 = (Dali::Toolkit::Control *)jarg1;
68240   if (!arg1) {
68241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68242     return 0;
68243   }
68244   {
68245     try {
68246       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68247     } catch (std::out_of_range& e) {
68248       {
68249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68250       };
68251     } catch (std::exception& e) {
68252       {
68253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68254       };
68255     } catch (Dali::DaliException e) {
68256       {
68257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68258       };
68259     } catch (...) {
68260       {
68261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68262       };
68263     }
68264   }
68265
68266   jresult = (void *)result;
68267   return jresult;
68268 }
68269
68270
68271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68272   unsigned int jresult ;
68273   Dali::Toolkit::Control *arg1 = 0 ;
68274   bool result;
68275
68276   arg1 = (Dali::Toolkit::Control *)jarg1;
68277   if (!arg1) {
68278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68279     return 0;
68280   }
68281   {
68282     try {
68283       result = (bool)arg1->IsResourceReady();
68284     } catch (std::out_of_range& e) {
68285       {
68286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68287       };
68288     } catch (std::exception& e) {
68289       {
68290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68291       };
68292     } catch (Dali::DaliException e) {
68293       {
68294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68295       };
68296     } catch (...) {
68297       {
68298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68299       };
68300     }
68301   }
68302
68303   jresult = result;
68304   return jresult;
68305 }
68306
68307
68308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68309   void * jresult ;
68310   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68311
68312   {
68313     try {
68314       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68315     } catch (std::out_of_range& e) {
68316       {
68317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68318       };
68319     } catch (std::exception& e) {
68320       {
68321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68322       };
68323     } catch (Dali::DaliException e) {
68324       {
68325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68326       };
68327     } catch (...) {
68328       {
68329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68330       };
68331     }
68332   }
68333
68334   jresult = (void *)result;
68335   return jresult;
68336 }
68337
68338
68339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68340   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68341
68342   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68343   {
68344     try {
68345       delete arg1;
68346     } catch (std::out_of_range& e) {
68347       {
68348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68349       };
68350     } catch (std::exception& e) {
68351       {
68352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68353       };
68354     } catch (Dali::DaliException e) {
68355       {
68356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68357       };
68358     } catch (...) {
68359       {
68360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68361       };
68362     }
68363   }
68364
68365 }
68366
68367
68368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68369   void * jresult ;
68370   Dali::Toolkit::KeyInputFocusManager result;
68371
68372   {
68373     try {
68374       result = Dali::Toolkit::KeyInputFocusManager::Get();
68375     } catch (std::out_of_range& e) {
68376       {
68377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68378       };
68379     } catch (std::exception& e) {
68380       {
68381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68382       };
68383     } catch (Dali::DaliException e) {
68384       {
68385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68386       };
68387     } catch (...) {
68388       {
68389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68390       };
68391     }
68392   }
68393
68394   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68395   return jresult;
68396 }
68397
68398
68399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68400   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68401   Dali::Toolkit::Control arg2 ;
68402   Dali::Toolkit::Control *argp2 ;
68403
68404   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68405   argp2 = (Dali::Toolkit::Control *)jarg2;
68406   if (!argp2) {
68407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68408     return ;
68409   }
68410   arg2 = *argp2;
68411   {
68412     try {
68413       (arg1)->SetFocus(arg2);
68414     } catch (std::out_of_range& e) {
68415       {
68416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68417       };
68418     } catch (std::exception& e) {
68419       {
68420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68421       };
68422     } catch (Dali::DaliException e) {
68423       {
68424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68425       };
68426     } catch (...) {
68427       {
68428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68429       };
68430     }
68431   }
68432
68433 }
68434
68435
68436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68437   void * jresult ;
68438   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68439   Dali::Toolkit::Control result;
68440
68441   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68442   {
68443     try {
68444       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68445     } catch (std::out_of_range& e) {
68446       {
68447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68448       };
68449     } catch (std::exception& e) {
68450       {
68451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68452       };
68453     } catch (Dali::DaliException e) {
68454       {
68455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68456       };
68457     } catch (...) {
68458       {
68459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68460       };
68461     }
68462   }
68463
68464   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68465   return jresult;
68466 }
68467
68468
68469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68470   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68471   Dali::Toolkit::Control arg2 ;
68472   Dali::Toolkit::Control *argp2 ;
68473
68474   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68475   argp2 = (Dali::Toolkit::Control *)jarg2;
68476   if (!argp2) {
68477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68478     return ;
68479   }
68480   arg2 = *argp2;
68481   {
68482     try {
68483       (arg1)->RemoveFocus(arg2);
68484     } catch (std::out_of_range& e) {
68485       {
68486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68487       };
68488     } catch (std::exception& e) {
68489       {
68490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68491       };
68492     } catch (Dali::DaliException e) {
68493       {
68494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68495       };
68496     } catch (...) {
68497       {
68498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68499       };
68500     }
68501   }
68502
68503 }
68504
68505
68506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68507   void * jresult ;
68508   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68509   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68510
68511   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68512   {
68513     try {
68514       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68515     } catch (std::out_of_range& e) {
68516       {
68517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68518       };
68519     } catch (std::exception& e) {
68520       {
68521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68522       };
68523     } catch (Dali::DaliException e) {
68524       {
68525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68526       };
68527     } catch (...) {
68528       {
68529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68530       };
68531     }
68532   }
68533
68534   jresult = (void *)result;
68535   return jresult;
68536 }
68537
68538
68539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68540   void * jresult ;
68541   Dali::Toolkit::Alignment::Padding *result = 0 ;
68542
68543   {
68544     try {
68545       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68546     } catch (std::out_of_range& e) {
68547       {
68548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68549       };
68550     } catch (std::exception& e) {
68551       {
68552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68553       };
68554     } catch (Dali::DaliException e) {
68555       {
68556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68557       };
68558     } catch (...) {
68559       {
68560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68561       };
68562     }
68563   }
68564
68565   jresult = (void *)result;
68566   return jresult;
68567 }
68568
68569
68570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68571   void * jresult ;
68572   float arg1 ;
68573   float arg2 ;
68574   float arg3 ;
68575   float arg4 ;
68576   Dali::Toolkit::Alignment::Padding *result = 0 ;
68577
68578   arg1 = (float)jarg1;
68579   arg2 = (float)jarg2;
68580   arg3 = (float)jarg3;
68581   arg4 = (float)jarg4;
68582   {
68583     try {
68584       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68585     } catch (std::out_of_range& e) {
68586       {
68587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68588       };
68589     } catch (std::exception& e) {
68590       {
68591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68592       };
68593     } catch (Dali::DaliException e) {
68594       {
68595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68596       };
68597     } catch (...) {
68598       {
68599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68600       };
68601     }
68602   }
68603
68604   jresult = (void *)result;
68605   return jresult;
68606 }
68607
68608
68609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68610   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68611   float arg2 ;
68612
68613   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68614   arg2 = (float)jarg2;
68615   if (arg1) (arg1)->left = arg2;
68616 }
68617
68618
68619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68620   float jresult ;
68621   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68622   float result;
68623
68624   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68625   result = (float) ((arg1)->left);
68626   jresult = result;
68627   return jresult;
68628 }
68629
68630
68631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68632   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68633   float arg2 ;
68634
68635   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68636   arg2 = (float)jarg2;
68637   if (arg1) (arg1)->right = arg2;
68638 }
68639
68640
68641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68642   float jresult ;
68643   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68644   float result;
68645
68646   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68647   result = (float) ((arg1)->right);
68648   jresult = result;
68649   return jresult;
68650 }
68651
68652
68653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68654   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68655   float arg2 ;
68656
68657   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68658   arg2 = (float)jarg2;
68659   if (arg1) (arg1)->top = arg2;
68660 }
68661
68662
68663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68664   float jresult ;
68665   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68666   float result;
68667
68668   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68669   result = (float) ((arg1)->top);
68670   jresult = result;
68671   return jresult;
68672 }
68673
68674
68675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68676   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68677   float arg2 ;
68678
68679   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68680   arg2 = (float)jarg2;
68681   if (arg1) (arg1)->bottom = arg2;
68682 }
68683
68684
68685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68686   float jresult ;
68687   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68688   float result;
68689
68690   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68691   result = (float) ((arg1)->bottom);
68692   jresult = result;
68693   return jresult;
68694 }
68695
68696
68697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68698   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68699
68700   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68701   {
68702     try {
68703       delete arg1;
68704     } catch (std::out_of_range& e) {
68705       {
68706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68707       };
68708     } catch (std::exception& e) {
68709       {
68710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68711       };
68712     } catch (Dali::DaliException e) {
68713       {
68714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68715       };
68716     } catch (...) {
68717       {
68718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68719       };
68720     }
68721   }
68722
68723 }
68724
68725
68726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68727   void * jresult ;
68728   Dali::Toolkit::Alignment *result = 0 ;
68729
68730   {
68731     try {
68732       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68733     } catch (std::out_of_range& e) {
68734       {
68735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68736       };
68737     } catch (std::exception& e) {
68738       {
68739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68740       };
68741     } catch (Dali::DaliException e) {
68742       {
68743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68744       };
68745     } catch (...) {
68746       {
68747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68748       };
68749     }
68750   }
68751
68752   jresult = (void *)result;
68753   return jresult;
68754 }
68755
68756
68757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68758   void * jresult ;
68759   Dali::Toolkit::Alignment::Type arg1 ;
68760   Dali::Toolkit::Alignment::Type arg2 ;
68761   Dali::Toolkit::Alignment result;
68762
68763   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68764   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68765   {
68766     try {
68767       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68768     } catch (std::out_of_range& e) {
68769       {
68770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68771       };
68772     } catch (std::exception& e) {
68773       {
68774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68775       };
68776     } catch (Dali::DaliException e) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68779       };
68780     } catch (...) {
68781       {
68782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68783       };
68784     }
68785   }
68786
68787   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68788   return jresult;
68789 }
68790
68791
68792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68793   void * jresult ;
68794   Dali::Toolkit::Alignment::Type arg1 ;
68795   Dali::Toolkit::Alignment result;
68796
68797   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68798   {
68799     try {
68800       result = Dali::Toolkit::Alignment::New(arg1);
68801     } catch (std::out_of_range& e) {
68802       {
68803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68804       };
68805     } catch (std::exception& e) {
68806       {
68807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68808       };
68809     } catch (Dali::DaliException e) {
68810       {
68811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68812       };
68813     } catch (...) {
68814       {
68815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68816       };
68817     }
68818   }
68819
68820   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68821   return jresult;
68822 }
68823
68824
68825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68826   void * jresult ;
68827   Dali::Toolkit::Alignment result;
68828
68829   {
68830     try {
68831       result = Dali::Toolkit::Alignment::New();
68832     } catch (std::out_of_range& e) {
68833       {
68834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68835       };
68836     } catch (std::exception& e) {
68837       {
68838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (Dali::DaliException e) {
68841       {
68842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68843       };
68844     } catch (...) {
68845       {
68846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68847       };
68848     }
68849   }
68850
68851   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68852   return jresult;
68853 }
68854
68855
68856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68857   void * jresult ;
68858   Dali::Toolkit::Alignment *arg1 = 0 ;
68859   Dali::Toolkit::Alignment *result = 0 ;
68860
68861   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68862   if (!arg1) {
68863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68864     return 0;
68865   }
68866   {
68867     try {
68868       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68869     } catch (std::out_of_range& e) {
68870       {
68871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68872       };
68873     } catch (std::exception& e) {
68874       {
68875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68876       };
68877     } catch (Dali::DaliException e) {
68878       {
68879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68880       };
68881     } catch (...) {
68882       {
68883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68884       };
68885     }
68886   }
68887
68888   jresult = (void *)result;
68889   return jresult;
68890 }
68891
68892
68893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68894   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68895
68896   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68897   {
68898     try {
68899       delete arg1;
68900     } catch (std::out_of_range& e) {
68901       {
68902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68903       };
68904     } catch (std::exception& e) {
68905       {
68906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68907       };
68908     } catch (Dali::DaliException e) {
68909       {
68910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68911       };
68912     } catch (...) {
68913       {
68914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68915       };
68916     }
68917   }
68918
68919 }
68920
68921
68922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68923   void * jresult ;
68924   Dali::BaseHandle arg1 ;
68925   Dali::BaseHandle *argp1 ;
68926   Dali::Toolkit::Alignment result;
68927
68928   argp1 = (Dali::BaseHandle *)jarg1;
68929   if (!argp1) {
68930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68931     return 0;
68932   }
68933   arg1 = *argp1;
68934   {
68935     try {
68936       result = Dali::Toolkit::Alignment::DownCast(arg1);
68937     } catch (std::out_of_range& e) {
68938       {
68939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68940       };
68941     } catch (std::exception& e) {
68942       {
68943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68944       };
68945     } catch (Dali::DaliException e) {
68946       {
68947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68948       };
68949     } catch (...) {
68950       {
68951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68952       };
68953     }
68954   }
68955
68956   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68957   return jresult;
68958 }
68959
68960
68961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68962   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68963   Dali::Toolkit::Alignment::Type arg2 ;
68964
68965   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68966   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68967   {
68968     try {
68969       (arg1)->SetAlignmentType(arg2);
68970     } catch (std::out_of_range& e) {
68971       {
68972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68973       };
68974     } catch (std::exception& e) {
68975       {
68976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68977       };
68978     } catch (Dali::DaliException e) {
68979       {
68980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68981       };
68982     } catch (...) {
68983       {
68984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68985       };
68986     }
68987   }
68988
68989 }
68990
68991
68992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68993   int jresult ;
68994   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68995   Dali::Toolkit::Alignment::Type result;
68996
68997   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68998   {
68999     try {
69000       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69001     } catch (std::out_of_range& e) {
69002       {
69003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69004       };
69005     } catch (std::exception& e) {
69006       {
69007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69008       };
69009     } catch (Dali::DaliException e) {
69010       {
69011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69012       };
69013     } catch (...) {
69014       {
69015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69016       };
69017     }
69018   }
69019
69020   jresult = (int)result;
69021   return jresult;
69022 }
69023
69024
69025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69026   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69027   Dali::Toolkit::Alignment::Scaling arg2 ;
69028
69029   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69030   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69031   {
69032     try {
69033       (arg1)->SetScaling(arg2);
69034     } catch (std::out_of_range& e) {
69035       {
69036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69037       };
69038     } catch (std::exception& e) {
69039       {
69040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69041       };
69042     } catch (Dali::DaliException e) {
69043       {
69044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69045       };
69046     } catch (...) {
69047       {
69048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69049       };
69050     }
69051   }
69052
69053 }
69054
69055
69056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69057   int jresult ;
69058   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69059   Dali::Toolkit::Alignment::Scaling result;
69060
69061   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69062   {
69063     try {
69064       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69065     } catch (std::out_of_range& e) {
69066       {
69067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69068       };
69069     } catch (std::exception& e) {
69070       {
69071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69072       };
69073     } catch (Dali::DaliException e) {
69074       {
69075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69076       };
69077     } catch (...) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69080       };
69081     }
69082   }
69083
69084   jresult = (int)result;
69085   return jresult;
69086 }
69087
69088
69089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69090   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69091   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69092
69093   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69094   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69095   if (!arg2) {
69096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69097     return ;
69098   }
69099   {
69100     try {
69101       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69102     } catch (std::out_of_range& e) {
69103       {
69104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69105       };
69106     } catch (std::exception& e) {
69107       {
69108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69109       };
69110     } catch (Dali::DaliException e) {
69111       {
69112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69113       };
69114     } catch (...) {
69115       {
69116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69117       };
69118     }
69119   }
69120
69121 }
69122
69123
69124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69125   void * jresult ;
69126   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69127   Dali::Toolkit::Alignment::Padding *result = 0 ;
69128
69129   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69130   {
69131     try {
69132       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69133     } catch (std::out_of_range& e) {
69134       {
69135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69136       };
69137     } catch (std::exception& e) {
69138       {
69139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69140       };
69141     } catch (Dali::DaliException e) {
69142       {
69143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69144       };
69145     } catch (...) {
69146       {
69147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69148       };
69149     }
69150   }
69151
69152   jresult = (void *)result;
69153   return jresult;
69154 }
69155
69156
69157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69158   void * jresult ;
69159   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69160   Dali::Toolkit::Alignment *arg2 = 0 ;
69161   Dali::Toolkit::Alignment *result = 0 ;
69162
69163   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69164   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69165   if (!arg2) {
69166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69167     return 0;
69168   }
69169   {
69170     try {
69171       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69172     } catch (std::out_of_range& e) {
69173       {
69174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69175       };
69176     } catch (std::exception& e) {
69177       {
69178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69179       };
69180     } catch (Dali::DaliException e) {
69181       {
69182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69183       };
69184     } catch (...) {
69185       {
69186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69187       };
69188     }
69189   }
69190
69191   jresult = (void *)result;
69192   return jresult;
69193 }
69194
69195
69196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69197   int jresult ;
69198   int result;
69199
69200   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69201   jresult = (int)result;
69202   return jresult;
69203 }
69204
69205
69206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69207   int jresult ;
69208   int result;
69209
69210   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69211   jresult = (int)result;
69212   return jresult;
69213 }
69214
69215
69216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69217   int jresult ;
69218   int result;
69219
69220   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69221   jresult = (int)result;
69222   return jresult;
69223 }
69224
69225
69226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69227   int jresult ;
69228   int result;
69229
69230   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69231   jresult = (int)result;
69232   return jresult;
69233 }
69234
69235
69236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69237   int jresult ;
69238   int result;
69239
69240   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69241   jresult = (int)result;
69242   return jresult;
69243 }
69244
69245
69246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69247   int jresult ;
69248   int result;
69249
69250   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69251   jresult = (int)result;
69252   return jresult;
69253 }
69254
69255
69256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69257   int jresult ;
69258   int result;
69259
69260   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69261   jresult = (int)result;
69262   return jresult;
69263 }
69264
69265
69266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69267   int jresult ;
69268   int result;
69269
69270   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69271   jresult = (int)result;
69272   return jresult;
69273 }
69274
69275
69276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69277   int jresult ;
69278   int result;
69279
69280   result = (int)Dali::Toolkit::Button::Property::LABEL;
69281   jresult = (int)result;
69282   return jresult;
69283 }
69284
69285
69286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69287   int jresult ;
69288   int result;
69289
69290   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69291   jresult = (int)result;
69292   return jresult;
69293 }
69294
69295
69296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69297   void * jresult ;
69298   Dali::Toolkit::Button::Property *result = 0 ;
69299
69300   {
69301     try {
69302       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69303     } catch (std::out_of_range& e) {
69304       {
69305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69306       };
69307     } catch (std::exception& e) {
69308       {
69309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69310       };
69311     } catch (Dali::DaliException e) {
69312       {
69313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69314       };
69315     } catch (...) {
69316       {
69317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69318       };
69319     }
69320   }
69321
69322   jresult = (void *)result;
69323   return jresult;
69324 }
69325
69326
69327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69328   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69329
69330   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69331   {
69332     try {
69333       delete arg1;
69334     } catch (std::out_of_range& e) {
69335       {
69336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69337       };
69338     } catch (std::exception& e) {
69339       {
69340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69341       };
69342     } catch (Dali::DaliException e) {
69343       {
69344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69345       };
69346     } catch (...) {
69347       {
69348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69349       };
69350     }
69351   }
69352
69353 }
69354
69355
69356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69357   void * jresult ;
69358   Dali::Toolkit::Button *result = 0 ;
69359
69360   {
69361     try {
69362       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69363     } catch (std::out_of_range& e) {
69364       {
69365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69366       };
69367     } catch (std::exception& e) {
69368       {
69369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69370       };
69371     } catch (Dali::DaliException e) {
69372       {
69373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69374       };
69375     } catch (...) {
69376       {
69377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69378       };
69379     }
69380   }
69381
69382   jresult = (void *)result;
69383   return jresult;
69384 }
69385
69386
69387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69388   void * jresult ;
69389   Dali::Toolkit::Button *arg1 = 0 ;
69390   Dali::Toolkit::Button *result = 0 ;
69391
69392   arg1 = (Dali::Toolkit::Button *)jarg1;
69393   if (!arg1) {
69394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69395     return 0;
69396   }
69397   {
69398     try {
69399       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69400     } catch (std::out_of_range& e) {
69401       {
69402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69403       };
69404     } catch (std::exception& e) {
69405       {
69406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69407       };
69408     } catch (Dali::DaliException e) {
69409       {
69410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69411       };
69412     } catch (...) {
69413       {
69414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69415       };
69416     }
69417   }
69418
69419   jresult = (void *)result;
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69425   void * jresult ;
69426   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69427   Dali::Toolkit::Button *arg2 = 0 ;
69428   Dali::Toolkit::Button *result = 0 ;
69429
69430   arg1 = (Dali::Toolkit::Button *)jarg1;
69431   arg2 = (Dali::Toolkit::Button *)jarg2;
69432   if (!arg2) {
69433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69434     return 0;
69435   }
69436   {
69437     try {
69438       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69439     } catch (std::out_of_range& e) {
69440       {
69441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69442       };
69443     } catch (std::exception& e) {
69444       {
69445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69446       };
69447     } catch (Dali::DaliException e) {
69448       {
69449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69450       };
69451     } catch (...) {
69452       {
69453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69454       };
69455     }
69456   }
69457
69458   jresult = (void *)result;
69459   return jresult;
69460 }
69461
69462
69463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69464   void * jresult ;
69465   Dali::BaseHandle arg1 ;
69466   Dali::BaseHandle *argp1 ;
69467   Dali::Toolkit::Button result;
69468
69469   argp1 = (Dali::BaseHandle *)jarg1;
69470   if (!argp1) {
69471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69472     return 0;
69473   }
69474   arg1 = *argp1;
69475   {
69476     try {
69477       result = Dali::Toolkit::Button::DownCast(arg1);
69478     } catch (std::out_of_range& e) {
69479       {
69480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69481       };
69482     } catch (std::exception& e) {
69483       {
69484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69485       };
69486     } catch (Dali::DaliException e) {
69487       {
69488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69489       };
69490     } catch (...) {
69491       {
69492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69493       };
69494     }
69495   }
69496
69497   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69498   return jresult;
69499 }
69500
69501
69502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69503   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69504
69505   arg1 = (Dali::Toolkit::Button *)jarg1;
69506   {
69507     try {
69508       delete arg1;
69509     } catch (std::out_of_range& e) {
69510       {
69511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69512       };
69513     } catch (std::exception& e) {
69514       {
69515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69516       };
69517     } catch (Dali::DaliException e) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69520       };
69521     } catch (...) {
69522       {
69523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69524       };
69525     }
69526   }
69527
69528 }
69529
69530
69531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69532   unsigned int jresult ;
69533   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69534   bool result;
69535
69536   arg1 = (Dali::Toolkit::Button *)jarg1;
69537   {
69538     try {
69539       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69540     } catch (std::out_of_range& e) {
69541       {
69542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69543       };
69544     } catch (std::exception& e) {
69545       {
69546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69547       };
69548     } catch (Dali::DaliException e) {
69549       {
69550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69551       };
69552     } catch (...) {
69553       {
69554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69555       };
69556     }
69557   }
69558
69559   jresult = result;
69560   return jresult;
69561 }
69562
69563
69564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69565   unsigned int jresult ;
69566   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69567   bool result;
69568
69569   arg1 = (Dali::Toolkit::Button *)jarg1;
69570   {
69571     try {
69572       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69573     } catch (std::out_of_range& e) {
69574       {
69575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69576       };
69577     } catch (std::exception& e) {
69578       {
69579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69580       };
69581     } catch (Dali::DaliException e) {
69582       {
69583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69584       };
69585     } catch (...) {
69586       {
69587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69588       };
69589     }
69590   }
69591
69592   jresult = result;
69593   return jresult;
69594 }
69595
69596
69597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69598   float jresult ;
69599   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69600   float result;
69601
69602   arg1 = (Dali::Toolkit::Button *)jarg1;
69603   {
69604     try {
69605       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69606     } catch (std::out_of_range& e) {
69607       {
69608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69609       };
69610     } catch (std::exception& e) {
69611       {
69612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69613       };
69614     } catch (Dali::DaliException e) {
69615       {
69616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69617       };
69618     } catch (...) {
69619       {
69620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69621       };
69622     }
69623   }
69624
69625   jresult = result;
69626   return jresult;
69627 }
69628
69629
69630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69631   float jresult ;
69632   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69633   float result;
69634
69635   arg1 = (Dali::Toolkit::Button *)jarg1;
69636   {
69637     try {
69638       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69639     } catch (std::out_of_range& e) {
69640       {
69641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69642       };
69643     } catch (std::exception& e) {
69644       {
69645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69646       };
69647     } catch (Dali::DaliException e) {
69648       {
69649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69650       };
69651     } catch (...) {
69652       {
69653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69654       };
69655     }
69656   }
69657
69658   jresult = result;
69659   return jresult;
69660 }
69661
69662
69663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69664   unsigned int jresult ;
69665   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69666   bool result;
69667
69668   arg1 = (Dali::Toolkit::Button *)jarg1;
69669   {
69670     try {
69671       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69672     } catch (std::out_of_range& e) {
69673       {
69674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69675       };
69676     } catch (std::exception& e) {
69677       {
69678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69679       };
69680     } catch (Dali::DaliException e) {
69681       {
69682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69683       };
69684     } catch (...) {
69685       {
69686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69687       };
69688     }
69689   }
69690
69691   jresult = result;
69692   return jresult;
69693 }
69694
69695
69696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69697   unsigned int jresult ;
69698   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69699   bool result;
69700
69701   arg1 = (Dali::Toolkit::Button *)jarg1;
69702   {
69703     try {
69704       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69705     } catch (std::out_of_range& e) {
69706       {
69707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69708       };
69709     } catch (std::exception& e) {
69710       {
69711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69712       };
69713     } catch (Dali::DaliException e) {
69714       {
69715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69716       };
69717     } catch (...) {
69718       {
69719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69720       };
69721     }
69722   }
69723
69724   jresult = result;
69725   return jresult;
69726 }
69727
69728
69729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69730   float jresult ;
69731   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69732   float result;
69733
69734   arg1 = (Dali::Toolkit::Button *)jarg1;
69735   {
69736     try {
69737       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69745       };
69746     } catch (Dali::DaliException e) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69749       };
69750     } catch (...) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69753       };
69754     }
69755   }
69756
69757   jresult = result;
69758   return jresult;
69759 }
69760
69761
69762 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69763   char * jresult ;
69764   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69765   std::string result;
69766
69767   arg1 = (Dali::Toolkit::Button *)jarg1;
69768   {
69769     try {
69770       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69771     } catch (std::out_of_range& e) {
69772       {
69773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69774       };
69775     } catch (std::exception& e) {
69776       {
69777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69778       };
69779     } catch (Dali::DaliException e) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69786       };
69787     }
69788   }
69789
69790   jresult = SWIG_csharp_string_callback((&result)->c_str());
69791   return jresult;
69792 }
69793
69794
69795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69796   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69797   Dali::Actor arg2 ;
69798   Dali::Actor *argp2 ;
69799
69800   arg1 = (Dali::Toolkit::Button *)jarg1;
69801   argp2 = (Dali::Actor *)jarg2;
69802   if (!argp2) {
69803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69804     return ;
69805   }
69806   arg2 = *argp2;
69807   {
69808     try {
69809       (arg1)->SetLabel(arg2);
69810     } catch (std::out_of_range& e) {
69811       {
69812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69813       };
69814     } catch (std::exception& e) {
69815       {
69816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69817       };
69818     } catch (Dali::DaliException e) {
69819       {
69820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69821       };
69822     } catch (...) {
69823       {
69824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69825       };
69826     }
69827   }
69828
69829 }
69830
69831
69832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69833   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69834   Dali::Image arg2 ;
69835   Dali::Image *argp2 ;
69836
69837   arg1 = (Dali::Toolkit::Button *)jarg1;
69838   argp2 = (Dali::Image *)jarg2;
69839   if (!argp2) {
69840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69841     return ;
69842   }
69843   arg2 = *argp2;
69844   {
69845     try {
69846       (arg1)->SetButtonImage(arg2);
69847     } catch (std::out_of_range& e) {
69848       {
69849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69850       };
69851     } catch (std::exception& e) {
69852       {
69853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69854       };
69855     } catch (Dali::DaliException e) {
69856       {
69857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69858       };
69859     } catch (...) {
69860       {
69861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69862       };
69863     }
69864   }
69865
69866 }
69867
69868
69869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69870   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69871   Dali::Image arg2 ;
69872   Dali::Image *argp2 ;
69873
69874   arg1 = (Dali::Toolkit::Button *)jarg1;
69875   argp2 = (Dali::Image *)jarg2;
69876   if (!argp2) {
69877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69878     return ;
69879   }
69880   arg2 = *argp2;
69881   {
69882     try {
69883       (arg1)->SetSelectedImage(arg2);
69884     } catch (std::out_of_range& e) {
69885       {
69886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69887       };
69888     } catch (std::exception& e) {
69889       {
69890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69891       };
69892     } catch (Dali::DaliException e) {
69893       {
69894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69895       };
69896     } catch (...) {
69897       {
69898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69899       };
69900     }
69901   }
69902
69903 }
69904
69905
69906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69907   void * jresult ;
69908   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69909   Dali::Actor result;
69910
69911   arg1 = (Dali::Toolkit::Button *)jarg1;
69912   {
69913     try {
69914       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69915     } catch (std::out_of_range& e) {
69916       {
69917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69918       };
69919     } catch (std::exception& e) {
69920       {
69921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69922       };
69923     } catch (Dali::DaliException e) {
69924       {
69925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69926       };
69927     } catch (...) {
69928       {
69929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69930       };
69931     }
69932   }
69933
69934   jresult = new Dali::Actor((const Dali::Actor &)result);
69935   return jresult;
69936 }
69937
69938
69939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69940   void * jresult ;
69941   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69942   Dali::Actor result;
69943
69944   arg1 = (Dali::Toolkit::Button *)jarg1;
69945   {
69946     try {
69947       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69948     } catch (std::out_of_range& e) {
69949       {
69950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69951       };
69952     } catch (std::exception& e) {
69953       {
69954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69955       };
69956     } catch (Dali::DaliException e) {
69957       {
69958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69959       };
69960     } catch (...) {
69961       {
69962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69963       };
69964     }
69965   }
69966
69967   jresult = new Dali::Actor((const Dali::Actor &)result);
69968   return jresult;
69969 }
69970
69971
69972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69973   void * jresult ;
69974   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69975   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69976
69977   arg1 = (Dali::Toolkit::Button *)jarg1;
69978   {
69979     try {
69980       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69981     } catch (std::out_of_range& e) {
69982       {
69983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (std::exception& e) {
69986       {
69987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69988       };
69989     } catch (Dali::DaliException e) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69992       };
69993     } catch (...) {
69994       {
69995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69996       };
69997     }
69998   }
69999
70000   jresult = (void *)result;
70001   return jresult;
70002 }
70003
70004
70005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70006   void * jresult ;
70007   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70008   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70009
70010   arg1 = (Dali::Toolkit::Button *)jarg1;
70011   {
70012     try {
70013       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70014     } catch (std::out_of_range& e) {
70015       {
70016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (std::exception& e) {
70019       {
70020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70021       };
70022     } catch (Dali::DaliException e) {
70023       {
70024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70025       };
70026     } catch (...) {
70027       {
70028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70029       };
70030     }
70031   }
70032
70033   jresult = (void *)result;
70034   return jresult;
70035 }
70036
70037
70038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70039   void * jresult ;
70040   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70041   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70042
70043   arg1 = (Dali::Toolkit::Button *)jarg1;
70044   {
70045     try {
70046       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70047     } catch (std::out_of_range& e) {
70048       {
70049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (std::exception& e) {
70052       {
70053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (Dali::DaliException e) {
70056       {
70057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70058       };
70059     } catch (...) {
70060       {
70061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70062       };
70063     }
70064   }
70065
70066   jresult = (void *)result;
70067   return jresult;
70068 }
70069
70070
70071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70072   void * jresult ;
70073   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70074   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70075
70076   arg1 = (Dali::Toolkit::Button *)jarg1;
70077   {
70078     try {
70079       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70080     } catch (std::out_of_range& e) {
70081       {
70082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70083       };
70084     } catch (std::exception& e) {
70085       {
70086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70087       };
70088     } catch (Dali::DaliException e) {
70089       {
70090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70091       };
70092     } catch (...) {
70093       {
70094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70095       };
70096     }
70097   }
70098
70099   jresult = (void *)result;
70100   return jresult;
70101 }
70102
70103
70104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70105   void * jresult ;
70106   Dali::Toolkit::CheckBoxButton *result = 0 ;
70107
70108   {
70109     try {
70110       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70111     } catch (std::out_of_range& e) {
70112       {
70113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (std::exception& e) {
70116       {
70117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70118       };
70119     } catch (Dali::DaliException e) {
70120       {
70121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70122       };
70123     } catch (...) {
70124       {
70125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70126       };
70127     }
70128   }
70129
70130   jresult = (void *)result;
70131   return jresult;
70132 }
70133
70134
70135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70136   void * jresult ;
70137   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70138   Dali::Toolkit::CheckBoxButton *result = 0 ;
70139
70140   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70141   if (!arg1) {
70142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70143     return 0;
70144   }
70145   {
70146     try {
70147       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70148     } catch (std::out_of_range& e) {
70149       {
70150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70151       };
70152     } catch (std::exception& e) {
70153       {
70154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70155       };
70156     } catch (Dali::DaliException e) {
70157       {
70158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70159       };
70160     } catch (...) {
70161       {
70162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70163       };
70164     }
70165   }
70166
70167   jresult = (void *)result;
70168   return jresult;
70169 }
70170
70171
70172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70173   void * jresult ;
70174   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70175   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70176   Dali::Toolkit::CheckBoxButton *result = 0 ;
70177
70178   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70179   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70180   if (!arg2) {
70181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70182     return 0;
70183   }
70184   {
70185     try {
70186       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70187     } catch (std::out_of_range& e) {
70188       {
70189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70190       };
70191     } catch (std::exception& e) {
70192       {
70193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70194       };
70195     } catch (Dali::DaliException e) {
70196       {
70197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70198       };
70199     } catch (...) {
70200       {
70201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70202       };
70203     }
70204   }
70205
70206   jresult = (void *)result;
70207   return jresult;
70208 }
70209
70210
70211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70212   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70213
70214   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70215   {
70216     try {
70217       delete arg1;
70218     } catch (std::out_of_range& e) {
70219       {
70220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70221       };
70222     } catch (std::exception& e) {
70223       {
70224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70225       };
70226     } catch (Dali::DaliException e) {
70227       {
70228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70229       };
70230     } catch (...) {
70231       {
70232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70233       };
70234     }
70235   }
70236
70237 }
70238
70239
70240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70241   void * jresult ;
70242   Dali::Toolkit::CheckBoxButton result;
70243
70244   {
70245     try {
70246       result = Dali::Toolkit::CheckBoxButton::New();
70247     } catch (std::out_of_range& e) {
70248       {
70249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70250       };
70251     } catch (std::exception& e) {
70252       {
70253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70254       };
70255     } catch (Dali::DaliException e) {
70256       {
70257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70258       };
70259     } catch (...) {
70260       {
70261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70262       };
70263     }
70264   }
70265
70266   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70267   return jresult;
70268 }
70269
70270
70271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70272   void * jresult ;
70273   Dali::BaseHandle arg1 ;
70274   Dali::BaseHandle *argp1 ;
70275   Dali::Toolkit::CheckBoxButton result;
70276
70277   argp1 = (Dali::BaseHandle *)jarg1;
70278   if (!argp1) {
70279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70280     return 0;
70281   }
70282   arg1 = *argp1;
70283   {
70284     try {
70285       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70286     } catch (std::out_of_range& e) {
70287       {
70288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70289       };
70290     } catch (std::exception& e) {
70291       {
70292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70293       };
70294     } catch (Dali::DaliException e) {
70295       {
70296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70297       };
70298     } catch (...) {
70299       {
70300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70301       };
70302     }
70303   }
70304
70305   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70306   return jresult;
70307 }
70308
70309
70310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70311   int jresult ;
70312   int result;
70313
70314   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70315   jresult = (int)result;
70316   return jresult;
70317 }
70318
70319
70320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70321   int jresult ;
70322   int result;
70323
70324   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70325   jresult = (int)result;
70326   return jresult;
70327 }
70328
70329
70330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70331   int jresult ;
70332   int result;
70333
70334   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70335   jresult = (int)result;
70336   return jresult;
70337 }
70338
70339
70340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70341   int jresult ;
70342   int result;
70343
70344   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70345   jresult = (int)result;
70346   return jresult;
70347 }
70348
70349
70350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70351   int jresult ;
70352   int result;
70353
70354   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70355   jresult = (int)result;
70356   return jresult;
70357 }
70358
70359
70360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70361   void * jresult ;
70362   Dali::Toolkit::PushButton::Property *result = 0 ;
70363
70364   {
70365     try {
70366       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70367     } catch (std::out_of_range& e) {
70368       {
70369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70370       };
70371     } catch (std::exception& e) {
70372       {
70373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70374       };
70375     } catch (Dali::DaliException e) {
70376       {
70377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70378       };
70379     } catch (...) {
70380       {
70381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70382       };
70383     }
70384   }
70385
70386   jresult = (void *)result;
70387   return jresult;
70388 }
70389
70390
70391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70392   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70393
70394   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70395   {
70396     try {
70397       delete arg1;
70398     } catch (std::out_of_range& e) {
70399       {
70400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70401       };
70402     } catch (std::exception& e) {
70403       {
70404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70405       };
70406     } catch (Dali::DaliException e) {
70407       {
70408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70409       };
70410     } catch (...) {
70411       {
70412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70413       };
70414     }
70415   }
70416
70417 }
70418
70419
70420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70421   void * jresult ;
70422   Dali::Toolkit::PushButton *result = 0 ;
70423
70424   {
70425     try {
70426       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70427     } catch (std::out_of_range& e) {
70428       {
70429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70430       };
70431     } catch (std::exception& e) {
70432       {
70433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70434       };
70435     } catch (Dali::DaliException e) {
70436       {
70437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70438       };
70439     } catch (...) {
70440       {
70441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70442       };
70443     }
70444   }
70445
70446   jresult = (void *)result;
70447   return jresult;
70448 }
70449
70450
70451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70452   void * jresult ;
70453   Dali::Toolkit::PushButton *arg1 = 0 ;
70454   Dali::Toolkit::PushButton *result = 0 ;
70455
70456   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70457   if (!arg1) {
70458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70459     return 0;
70460   }
70461   {
70462     try {
70463       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70464     } catch (std::out_of_range& e) {
70465       {
70466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70467       };
70468     } catch (std::exception& e) {
70469       {
70470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70471       };
70472     } catch (Dali::DaliException e) {
70473       {
70474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70475       };
70476     } catch (...) {
70477       {
70478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70479       };
70480     }
70481   }
70482
70483   jresult = (void *)result;
70484   return jresult;
70485 }
70486
70487
70488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70489   void * jresult ;
70490   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70491   Dali::Toolkit::PushButton *arg2 = 0 ;
70492   Dali::Toolkit::PushButton *result = 0 ;
70493
70494   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70495   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70496   if (!arg2) {
70497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70498     return 0;
70499   }
70500   {
70501     try {
70502       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70503     } catch (std::out_of_range& e) {
70504       {
70505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70506       };
70507     } catch (std::exception& e) {
70508       {
70509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70510       };
70511     } catch (Dali::DaliException e) {
70512       {
70513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70514       };
70515     } catch (...) {
70516       {
70517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70518       };
70519     }
70520   }
70521
70522   jresult = (void *)result;
70523   return jresult;
70524 }
70525
70526
70527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70528   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70529
70530   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70531   {
70532     try {
70533       delete arg1;
70534     } catch (std::out_of_range& e) {
70535       {
70536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70537       };
70538     } catch (std::exception& e) {
70539       {
70540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70541       };
70542     } catch (Dali::DaliException e) {
70543       {
70544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70545       };
70546     } catch (...) {
70547       {
70548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70549       };
70550     }
70551   }
70552
70553 }
70554
70555
70556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70557   void * jresult ;
70558   Dali::Toolkit::PushButton result;
70559
70560   {
70561     try {
70562       result = Dali::Toolkit::PushButton::New();
70563     } catch (std::out_of_range& e) {
70564       {
70565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70566       };
70567     } catch (std::exception& e) {
70568       {
70569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70570       };
70571     } catch (Dali::DaliException e) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70574       };
70575     } catch (...) {
70576       {
70577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70578       };
70579     }
70580   }
70581
70582   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70583   return jresult;
70584 }
70585
70586
70587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70588   void * jresult ;
70589   Dali::BaseHandle arg1 ;
70590   Dali::BaseHandle *argp1 ;
70591   Dali::Toolkit::PushButton result;
70592
70593   argp1 = (Dali::BaseHandle *)jarg1;
70594   if (!argp1) {
70595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70596     return 0;
70597   }
70598   arg1 = *argp1;
70599   {
70600     try {
70601       result = Dali::Toolkit::PushButton::DownCast(arg1);
70602     } catch (std::out_of_range& e) {
70603       {
70604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70605       };
70606     } catch (std::exception& e) {
70607       {
70608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70609       };
70610     } catch (Dali::DaliException e) {
70611       {
70612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70613       };
70614     } catch (...) {
70615       {
70616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70617       };
70618     }
70619   }
70620
70621   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70622   return jresult;
70623 }
70624
70625
70626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70627   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70628   Dali::Image arg2 ;
70629   Dali::Image *argp2 ;
70630
70631   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70632   argp2 = (Dali::Image *)jarg2;
70633   if (!argp2) {
70634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70635     return ;
70636   }
70637   arg2 = *argp2;
70638   {
70639     try {
70640       (arg1)->SetButtonImage(arg2);
70641     } catch (std::out_of_range& e) {
70642       {
70643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70644       };
70645     } catch (std::exception& e) {
70646       {
70647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70648       };
70649     } catch (Dali::DaliException e) {
70650       {
70651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70652       };
70653     } catch (...) {
70654       {
70655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70656       };
70657     }
70658   }
70659
70660 }
70661
70662
70663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70664   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70665   Dali::Actor arg2 ;
70666   Dali::Actor *argp2 ;
70667
70668   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70669   argp2 = (Dali::Actor *)jarg2;
70670   if (!argp2) {
70671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70672     return ;
70673   }
70674   arg2 = *argp2;
70675   {
70676     try {
70677       (arg1)->SetButtonImage(arg2);
70678     } catch (std::out_of_range& e) {
70679       {
70680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70681       };
70682     } catch (std::exception& e) {
70683       {
70684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70685       };
70686     } catch (Dali::DaliException e) {
70687       {
70688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70689       };
70690     } catch (...) {
70691       {
70692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70693       };
70694     }
70695   }
70696
70697 }
70698
70699
70700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70701   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70702   Dali::Actor arg2 ;
70703   Dali::Actor *argp2 ;
70704
70705   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70706   argp2 = (Dali::Actor *)jarg2;
70707   if (!argp2) {
70708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70709     return ;
70710   }
70711   arg2 = *argp2;
70712   {
70713     try {
70714       (arg1)->SetBackgroundImage(arg2);
70715     } catch (std::out_of_range& e) {
70716       {
70717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70718       };
70719     } catch (std::exception& e) {
70720       {
70721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70722       };
70723     } catch (Dali::DaliException e) {
70724       {
70725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70726       };
70727     } catch (...) {
70728       {
70729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70730       };
70731     }
70732   }
70733
70734 }
70735
70736
70737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70738   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70739   Dali::Image arg2 ;
70740   Dali::Image *argp2 ;
70741
70742   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70743   argp2 = (Dali::Image *)jarg2;
70744   if (!argp2) {
70745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70746     return ;
70747   }
70748   arg2 = *argp2;
70749   {
70750     try {
70751       (arg1)->SetSelectedImage(arg2);
70752     } catch (std::out_of_range& e) {
70753       {
70754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70755       };
70756     } catch (std::exception& e) {
70757       {
70758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70759       };
70760     } catch (Dali::DaliException e) {
70761       {
70762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70763       };
70764     } catch (...) {
70765       {
70766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70767       };
70768     }
70769   }
70770
70771 }
70772
70773
70774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70775   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70776   Dali::Actor arg2 ;
70777   Dali::Actor *argp2 ;
70778
70779   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70780   argp2 = (Dali::Actor *)jarg2;
70781   if (!argp2) {
70782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70783     return ;
70784   }
70785   arg2 = *argp2;
70786   {
70787     try {
70788       (arg1)->SetSelectedImage(arg2);
70789     } catch (std::out_of_range& e) {
70790       {
70791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70792       };
70793     } catch (std::exception& e) {
70794       {
70795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70796       };
70797     } catch (Dali::DaliException e) {
70798       {
70799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70800       };
70801     } catch (...) {
70802       {
70803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70804       };
70805     }
70806   }
70807
70808 }
70809
70810
70811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70812   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70813   Dali::Actor arg2 ;
70814   Dali::Actor *argp2 ;
70815
70816   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70817   argp2 = (Dali::Actor *)jarg2;
70818   if (!argp2) {
70819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70820     return ;
70821   }
70822   arg2 = *argp2;
70823   {
70824     try {
70825       (arg1)->SetSelectedBackgroundImage(arg2);
70826     } catch (std::out_of_range& e) {
70827       {
70828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70829       };
70830     } catch (std::exception& e) {
70831       {
70832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70833       };
70834     } catch (Dali::DaliException e) {
70835       {
70836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70837       };
70838     } catch (...) {
70839       {
70840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70841       };
70842     }
70843   }
70844
70845 }
70846
70847
70848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70849   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70850   Dali::Actor arg2 ;
70851   Dali::Actor *argp2 ;
70852
70853   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70854   argp2 = (Dali::Actor *)jarg2;
70855   if (!argp2) {
70856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70857     return ;
70858   }
70859   arg2 = *argp2;
70860   {
70861     try {
70862       (arg1)->SetDisabledBackgroundImage(arg2);
70863     } catch (std::out_of_range& e) {
70864       {
70865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70866       };
70867     } catch (std::exception& e) {
70868       {
70869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70870       };
70871     } catch (Dali::DaliException e) {
70872       {
70873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70874       };
70875     } catch (...) {
70876       {
70877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70878       };
70879     }
70880   }
70881
70882 }
70883
70884
70885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70886   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70887   Dali::Actor arg2 ;
70888   Dali::Actor *argp2 ;
70889
70890   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70891   argp2 = (Dali::Actor *)jarg2;
70892   if (!argp2) {
70893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70894     return ;
70895   }
70896   arg2 = *argp2;
70897   {
70898     try {
70899       (arg1)->SetDisabledImage(arg2);
70900     } catch (std::out_of_range& e) {
70901       {
70902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70903       };
70904     } catch (std::exception& e) {
70905       {
70906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70907       };
70908     } catch (Dali::DaliException e) {
70909       {
70910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70911       };
70912     } catch (...) {
70913       {
70914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70915       };
70916     }
70917   }
70918
70919 }
70920
70921
70922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70923   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70924   Dali::Actor arg2 ;
70925   Dali::Actor *argp2 ;
70926
70927   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70928   argp2 = (Dali::Actor *)jarg2;
70929   if (!argp2) {
70930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70931     return ;
70932   }
70933   arg2 = *argp2;
70934   {
70935     try {
70936       (arg1)->SetDisabledSelectedImage(arg2);
70937     } catch (std::out_of_range& e) {
70938       {
70939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70940       };
70941     } catch (std::exception& e) {
70942       {
70943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70944       };
70945     } catch (Dali::DaliException e) {
70946       {
70947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70948       };
70949     } catch (...) {
70950       {
70951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70952       };
70953     }
70954   }
70955
70956 }
70957
70958
70959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70960   void * jresult ;
70961   Dali::Toolkit::RadioButton *result = 0 ;
70962
70963   {
70964     try {
70965       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70966     } catch (std::out_of_range& e) {
70967       {
70968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70969       };
70970     } catch (std::exception& e) {
70971       {
70972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70973       };
70974     } catch (Dali::DaliException e) {
70975       {
70976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70977       };
70978     } catch (...) {
70979       {
70980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70981       };
70982     }
70983   }
70984
70985   jresult = (void *)result;
70986   return jresult;
70987 }
70988
70989
70990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70991   void * jresult ;
70992   Dali::Toolkit::RadioButton *arg1 = 0 ;
70993   Dali::Toolkit::RadioButton *result = 0 ;
70994
70995   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70996   if (!arg1) {
70997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70998     return 0;
70999   }
71000   {
71001     try {
71002       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71003     } catch (std::out_of_range& e) {
71004       {
71005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71006       };
71007     } catch (std::exception& e) {
71008       {
71009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71010       };
71011     } catch (Dali::DaliException e) {
71012       {
71013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71014       };
71015     } catch (...) {
71016       {
71017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71018       };
71019     }
71020   }
71021
71022   jresult = (void *)result;
71023   return jresult;
71024 }
71025
71026
71027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71028   void * jresult ;
71029   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71030   Dali::Toolkit::RadioButton *arg2 = 0 ;
71031   Dali::Toolkit::RadioButton *result = 0 ;
71032
71033   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71034   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71035   if (!arg2) {
71036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71037     return 0;
71038   }
71039   {
71040     try {
71041       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71042     } catch (std::out_of_range& e) {
71043       {
71044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71045       };
71046     } catch (std::exception& e) {
71047       {
71048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71049       };
71050     } catch (Dali::DaliException e) {
71051       {
71052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71053       };
71054     } catch (...) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71057       };
71058     }
71059   }
71060
71061   jresult = (void *)result;
71062   return jresult;
71063 }
71064
71065
71066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71067   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71068
71069   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71070   {
71071     try {
71072       delete arg1;
71073     } catch (std::out_of_range& e) {
71074       {
71075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71076       };
71077     } catch (std::exception& e) {
71078       {
71079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71080       };
71081     } catch (Dali::DaliException e) {
71082       {
71083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71084       };
71085     } catch (...) {
71086       {
71087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71088       };
71089     }
71090   }
71091
71092 }
71093
71094
71095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71096   void * jresult ;
71097   Dali::Toolkit::RadioButton result;
71098
71099   {
71100     try {
71101       result = Dali::Toolkit::RadioButton::New();
71102     } catch (std::out_of_range& e) {
71103       {
71104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71105       };
71106     } catch (std::exception& e) {
71107       {
71108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71109       };
71110     } catch (Dali::DaliException e) {
71111       {
71112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71113       };
71114     } catch (...) {
71115       {
71116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71117       };
71118     }
71119   }
71120
71121   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71122   return jresult;
71123 }
71124
71125
71126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71127   void * jresult ;
71128   std::string *arg1 = 0 ;
71129   Dali::Toolkit::RadioButton result;
71130
71131   if (!jarg1) {
71132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71133     return 0;
71134   }
71135   std::string arg1_str(jarg1);
71136   arg1 = &arg1_str;
71137   {
71138     try {
71139       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71140     } catch (std::out_of_range& e) {
71141       {
71142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71143       };
71144     } catch (std::exception& e) {
71145       {
71146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71147       };
71148     } catch (Dali::DaliException e) {
71149       {
71150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71151       };
71152     } catch (...) {
71153       {
71154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71155       };
71156     }
71157   }
71158
71159   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71160
71161   //argout typemap for const std::string&
71162
71163   return jresult;
71164 }
71165
71166
71167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71168   void * jresult ;
71169   Dali::BaseHandle arg1 ;
71170   Dali::BaseHandle *argp1 ;
71171   Dali::Toolkit::RadioButton result;
71172
71173   argp1 = (Dali::BaseHandle *)jarg1;
71174   if (!argp1) {
71175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71176     return 0;
71177   }
71178   arg1 = *argp1;
71179   {
71180     try {
71181       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71182     } catch (std::out_of_range& e) {
71183       {
71184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71185       };
71186     } catch (std::exception& e) {
71187       {
71188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71189       };
71190     } catch (Dali::DaliException e) {
71191       {
71192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71193       };
71194     } catch (...) {
71195       {
71196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71197       };
71198     }
71199   }
71200
71201   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71202   return jresult;
71203 }
71204
71205
71206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71207   int jresult ;
71208   int result;
71209
71210   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71211   jresult = (int)result;
71212   return jresult;
71213 }
71214
71215
71216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71217   int jresult ;
71218   int result;
71219
71220   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71221   jresult = (int)result;
71222   return jresult;
71223 }
71224
71225
71226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71227   int jresult ;
71228   int result;
71229
71230   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71231   jresult = (int)result;
71232   return jresult;
71233 }
71234
71235
71236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71237   int jresult ;
71238   int result;
71239
71240   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71241   jresult = (int)result;
71242   return jresult;
71243 }
71244
71245
71246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71247   int jresult ;
71248   int result;
71249
71250   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71251   jresult = (int)result;
71252   return jresult;
71253 }
71254
71255
71256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71257   int jresult ;
71258   int result;
71259
71260   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71261   jresult = (int)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71267   void * jresult ;
71268   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71269
71270   {
71271     try {
71272       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71273     } catch (std::out_of_range& e) {
71274       {
71275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71276       };
71277     } catch (std::exception& e) {
71278       {
71279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71280       };
71281     } catch (Dali::DaliException e) {
71282       {
71283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71284       };
71285     } catch (...) {
71286       {
71287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71288       };
71289     }
71290   }
71291
71292   jresult = (void *)result;
71293   return jresult;
71294 }
71295
71296
71297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71298   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71299
71300   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71301   {
71302     try {
71303       delete arg1;
71304     } catch (std::out_of_range& e) {
71305       {
71306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71307       };
71308     } catch (std::exception& e) {
71309       {
71310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71311       };
71312     } catch (Dali::DaliException e) {
71313       {
71314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71315       };
71316     } catch (...) {
71317       {
71318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71319       };
71320     }
71321   }
71322
71323 }
71324
71325
71326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71327   int jresult ;
71328   int result;
71329
71330   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71331   jresult = (int)result;
71332   return jresult;
71333 }
71334
71335
71336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71337   int jresult ;
71338   int result;
71339
71340   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71341   jresult = (int)result;
71342   return jresult;
71343 }
71344
71345
71346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71347   int jresult ;
71348   int result;
71349
71350   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71351   jresult = (int)result;
71352   return jresult;
71353 }
71354
71355
71356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71357   void * jresult ;
71358   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71359
71360   {
71361     try {
71362       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71363     } catch (std::out_of_range& e) {
71364       {
71365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71366       };
71367     } catch (std::exception& e) {
71368       {
71369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71370       };
71371     } catch (Dali::DaliException e) {
71372       {
71373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71374       };
71375     } catch (...) {
71376       {
71377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71378       };
71379     }
71380   }
71381
71382   jresult = (void *)result;
71383   return jresult;
71384 }
71385
71386
71387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71388   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71389
71390   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71391   {
71392     try {
71393       delete arg1;
71394     } catch (std::out_of_range& e) {
71395       {
71396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71397       };
71398     } catch (std::exception& e) {
71399       {
71400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71401       };
71402     } catch (Dali::DaliException e) {
71403       {
71404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71405       };
71406     } catch (...) {
71407       {
71408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71409       };
71410     }
71411   }
71412
71413 }
71414
71415
71416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71417   void * jresult ;
71418   Dali::Toolkit::FlexContainer *result = 0 ;
71419
71420   {
71421     try {
71422       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71423     } catch (std::out_of_range& e) {
71424       {
71425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71426       };
71427     } catch (std::exception& e) {
71428       {
71429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71430       };
71431     } catch (Dali::DaliException e) {
71432       {
71433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71438       };
71439     }
71440   }
71441
71442   jresult = (void *)result;
71443   return jresult;
71444 }
71445
71446
71447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71448   void * jresult ;
71449   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71450   Dali::Toolkit::FlexContainer *result = 0 ;
71451
71452   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71453   if (!arg1) {
71454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71455     return 0;
71456   }
71457   {
71458     try {
71459       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71460     } catch (std::out_of_range& e) {
71461       {
71462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71463       };
71464     } catch (std::exception& e) {
71465       {
71466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71467       };
71468     } catch (Dali::DaliException e) {
71469       {
71470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71471       };
71472     } catch (...) {
71473       {
71474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71475       };
71476     }
71477   }
71478
71479   jresult = (void *)result;
71480   return jresult;
71481 }
71482
71483
71484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71485   void * jresult ;
71486   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71487   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71488   Dali::Toolkit::FlexContainer *result = 0 ;
71489
71490   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71491   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71492   if (!arg2) {
71493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71494     return 0;
71495   }
71496   {
71497     try {
71498       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71499     } catch (std::out_of_range& e) {
71500       {
71501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71502       };
71503     } catch (std::exception& e) {
71504       {
71505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71506       };
71507     } catch (Dali::DaliException e) {
71508       {
71509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71510       };
71511     } catch (...) {
71512       {
71513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71514       };
71515     }
71516   }
71517
71518   jresult = (void *)result;
71519   return jresult;
71520 }
71521
71522
71523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71524   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71525
71526   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71527   {
71528     try {
71529       delete arg1;
71530     } catch (std::out_of_range& e) {
71531       {
71532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71533       };
71534     } catch (std::exception& e) {
71535       {
71536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71537       };
71538     } catch (Dali::DaliException e) {
71539       {
71540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71541       };
71542     } catch (...) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71545       };
71546     }
71547   }
71548
71549 }
71550
71551
71552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71553   void * jresult ;
71554   Dali::Toolkit::FlexContainer result;
71555
71556   {
71557     try {
71558       result = Dali::Toolkit::FlexContainer::New();
71559     } catch (std::out_of_range& e) {
71560       {
71561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71562       };
71563     } catch (std::exception& e) {
71564       {
71565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71566       };
71567     } catch (Dali::DaliException e) {
71568       {
71569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71570       };
71571     } catch (...) {
71572       {
71573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71574       };
71575     }
71576   }
71577
71578   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71579   return jresult;
71580 }
71581
71582
71583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71584   void * jresult ;
71585   Dali::BaseHandle arg1 ;
71586   Dali::BaseHandle *argp1 ;
71587   Dali::Toolkit::FlexContainer result;
71588
71589   argp1 = (Dali::BaseHandle *)jarg1;
71590   if (!argp1) {
71591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71592     return 0;
71593   }
71594   arg1 = *argp1;
71595   {
71596     try {
71597       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71598     } catch (std::out_of_range& e) {
71599       {
71600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71601       };
71602     } catch (std::exception& e) {
71603       {
71604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71605       };
71606     } catch (Dali::DaliException e) {
71607       {
71608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71609       };
71610     } catch (...) {
71611       {
71612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71613       };
71614     }
71615   }
71616
71617   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71618   return jresult;
71619 }
71620
71621
71622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71623   int jresult ;
71624   int result;
71625
71626   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71627   jresult = (int)result;
71628   return jresult;
71629 }
71630
71631
71632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71633   int jresult ;
71634   int result;
71635
71636   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71637   jresult = (int)result;
71638   return jresult;
71639 }
71640
71641
71642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71643   int jresult ;
71644   int result;
71645
71646   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71647   jresult = (int)result;
71648   return jresult;
71649 }
71650
71651
71652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71653   int jresult ;
71654   int result;
71655
71656   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71657   jresult = (int)result;
71658   return jresult;
71659 }
71660
71661
71662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71663   void * jresult ;
71664   Dali::Toolkit::ImageView::Property *result = 0 ;
71665
71666   {
71667     try {
71668       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71669     } catch (std::out_of_range& e) {
71670       {
71671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71672       };
71673     } catch (std::exception& e) {
71674       {
71675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71676       };
71677     } catch (Dali::DaliException e) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71680       };
71681     } catch (...) {
71682       {
71683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71684       };
71685     }
71686   }
71687
71688   jresult = (void *)result;
71689   return jresult;
71690 }
71691
71692
71693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71694   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71695
71696   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71697   {
71698     try {
71699       delete arg1;
71700     } catch (std::out_of_range& e) {
71701       {
71702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71703       };
71704     } catch (std::exception& e) {
71705       {
71706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71707       };
71708     } catch (Dali::DaliException e) {
71709       {
71710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71711       };
71712     } catch (...) {
71713       {
71714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71715       };
71716     }
71717   }
71718
71719 }
71720
71721
71722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71723   void * jresult ;
71724   Dali::Toolkit::ImageView *result = 0 ;
71725
71726   {
71727     try {
71728       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71729     } catch (std::out_of_range& e) {
71730       {
71731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71732       };
71733     } catch (std::exception& e) {
71734       {
71735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71736       };
71737     } catch (Dali::DaliException e) {
71738       {
71739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71740       };
71741     } catch (...) {
71742       {
71743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71744       };
71745     }
71746   }
71747
71748   jresult = (void *)result;
71749   return jresult;
71750 }
71751
71752
71753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71754   void * jresult ;
71755   Dali::Toolkit::ImageView result;
71756
71757   {
71758     try {
71759       result = Dali::Toolkit::ImageView::New();
71760     } catch (std::out_of_range& e) {
71761       {
71762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71763       };
71764     } catch (std::exception& e) {
71765       {
71766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71767       };
71768     } catch (Dali::DaliException e) {
71769       {
71770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71771       };
71772     } catch (...) {
71773       {
71774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71775       };
71776     }
71777   }
71778
71779   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71780   return jresult;
71781 }
71782
71783
71784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71785   void * jresult ;
71786   Dali::Image arg1 ;
71787   Dali::Image *argp1 ;
71788   Dali::Toolkit::ImageView result;
71789
71790   argp1 = (Dali::Image *)jarg1;
71791   if (!argp1) {
71792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71793     return 0;
71794   }
71795   arg1 = *argp1;
71796   {
71797     try {
71798       result = Dali::Toolkit::ImageView::New(arg1);
71799     } catch (std::out_of_range& e) {
71800       {
71801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71802       };
71803     } catch (std::exception& e) {
71804       {
71805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71806       };
71807     } catch (Dali::DaliException e) {
71808       {
71809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71810       };
71811     } catch (...) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71814       };
71815     }
71816   }
71817
71818   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71819   return jresult;
71820 }
71821
71822
71823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71824   void * jresult ;
71825   std::string *arg1 = 0 ;
71826   Dali::Toolkit::ImageView result;
71827
71828   if (!jarg1) {
71829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71830     return 0;
71831   }
71832   std::string arg1_str(jarg1);
71833   arg1 = &arg1_str;
71834   {
71835     try {
71836       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71837     } catch (std::out_of_range& e) {
71838       {
71839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71840       };
71841     } catch (std::exception& e) {
71842       {
71843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71844       };
71845     } catch (Dali::DaliException e) {
71846       {
71847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71848       };
71849     } catch (...) {
71850       {
71851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71852       };
71853     }
71854   }
71855
71856   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71857
71858   //argout typemap for const std::string&
71859
71860   return jresult;
71861 }
71862
71863
71864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71865   void * jresult ;
71866   std::string *arg1 = 0 ;
71867   Dali::ImageDimensions arg2 ;
71868   Dali::ImageDimensions *argp2 ;
71869   Dali::Toolkit::ImageView result;
71870
71871   if (!jarg1) {
71872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71873     return 0;
71874   }
71875   std::string arg1_str(jarg1);
71876   arg1 = &arg1_str;
71877   argp2 = (Dali::ImageDimensions *)jarg2;
71878   if (!argp2) {
71879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71880     return 0;
71881   }
71882   arg2 = *argp2;
71883   {
71884     try {
71885       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71886     } catch (std::out_of_range& e) {
71887       {
71888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71889       };
71890     } catch (std::exception& e) {
71891       {
71892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71893       };
71894     } catch (Dali::DaliException e) {
71895       {
71896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71897       };
71898     } catch (...) {
71899       {
71900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71901       };
71902     }
71903   }
71904
71905   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71906
71907   //argout typemap for const std::string&
71908
71909   return jresult;
71910 }
71911
71912
71913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71914   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71915
71916   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71917   {
71918     try {
71919       delete arg1;
71920     } catch (std::out_of_range& e) {
71921       {
71922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71923       };
71924     } catch (std::exception& e) {
71925       {
71926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71927       };
71928     } catch (Dali::DaliException e) {
71929       {
71930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71931       };
71932     } catch (...) {
71933       {
71934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71935       };
71936     }
71937   }
71938
71939 }
71940
71941
71942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71943   void * jresult ;
71944   Dali::Toolkit::ImageView *arg1 = 0 ;
71945   Dali::Toolkit::ImageView *result = 0 ;
71946
71947   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71948   if (!arg1) {
71949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71950     return 0;
71951   }
71952   {
71953     try {
71954       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71955     } catch (std::out_of_range& e) {
71956       {
71957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71958       };
71959     } catch (std::exception& e) {
71960       {
71961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71962       };
71963     } catch (Dali::DaliException e) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71966       };
71967     } catch (...) {
71968       {
71969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71970       };
71971     }
71972   }
71973
71974   jresult = (void *)result;
71975   return jresult;
71976 }
71977
71978
71979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71980   void * jresult ;
71981   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71982   Dali::Toolkit::ImageView *arg2 = 0 ;
71983   Dali::Toolkit::ImageView *result = 0 ;
71984
71985   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71986   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71987   if (!arg2) {
71988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71989     return 0;
71990   }
71991   {
71992     try {
71993       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71994     } catch (std::out_of_range& e) {
71995       {
71996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71997       };
71998     } catch (std::exception& e) {
71999       {
72000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72001       };
72002     } catch (Dali::DaliException e) {
72003       {
72004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72005       };
72006     } catch (...) {
72007       {
72008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72009       };
72010     }
72011   }
72012
72013   jresult = (void *)result;
72014   return jresult;
72015 }
72016
72017
72018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72019   void * jresult ;
72020   Dali::BaseHandle arg1 ;
72021   Dali::BaseHandle *argp1 ;
72022   Dali::Toolkit::ImageView result;
72023
72024   argp1 = (Dali::BaseHandle *)jarg1;
72025   if (!argp1) {
72026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72027     return 0;
72028   }
72029   arg1 = *argp1;
72030   {
72031     try {
72032       result = Dali::Toolkit::ImageView::DownCast(arg1);
72033     } catch (std::out_of_range& e) {
72034       {
72035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72036       };
72037     } catch (std::exception& e) {
72038       {
72039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72040       };
72041     } catch (Dali::DaliException e) {
72042       {
72043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72044       };
72045     } catch (...) {
72046       {
72047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72048       };
72049     }
72050   }
72051
72052   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72053   return jresult;
72054 }
72055
72056
72057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72058   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72059   Dali::Image arg2 ;
72060   Dali::Image *argp2 ;
72061
72062   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72063   argp2 = (Dali::Image *)jarg2;
72064   if (!argp2) {
72065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72066     return ;
72067   }
72068   arg2 = *argp2;
72069   {
72070     try {
72071       (arg1)->SetImage(arg2);
72072     } catch (std::out_of_range& e) {
72073       {
72074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72075       };
72076     } catch (std::exception& e) {
72077       {
72078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72079       };
72080     } catch (Dali::DaliException e) {
72081       {
72082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72083       };
72084     } catch (...) {
72085       {
72086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72087       };
72088     }
72089   }
72090
72091 }
72092
72093
72094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72095   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72096   std::string *arg2 = 0 ;
72097
72098   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72099   if (!jarg2) {
72100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72101     return ;
72102   }
72103   std::string arg2_str(jarg2);
72104   arg2 = &arg2_str;
72105   {
72106     try {
72107       (arg1)->SetImage((std::string const &)*arg2);
72108     } catch (std::out_of_range& e) {
72109       {
72110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72111       };
72112     } catch (std::exception& e) {
72113       {
72114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72115       };
72116     } catch (Dali::DaliException e) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72119       };
72120     } catch (...) {
72121       {
72122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72123       };
72124     }
72125   }
72126
72127
72128   //argout typemap for const std::string&
72129
72130 }
72131
72132
72133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72134   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72135   std::string *arg2 = 0 ;
72136   Dali::ImageDimensions arg3 ;
72137   Dali::ImageDimensions *argp3 ;
72138
72139   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72140   if (!jarg2) {
72141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72142     return ;
72143   }
72144   std::string arg2_str(jarg2);
72145   arg2 = &arg2_str;
72146   argp3 = (Dali::ImageDimensions *)jarg3;
72147   if (!argp3) {
72148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72149     return ;
72150   }
72151   arg3 = *argp3;
72152   {
72153     try {
72154       (arg1)->SetImage((std::string const &)*arg2,arg3);
72155     } catch (std::out_of_range& e) {
72156       {
72157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72158       };
72159     } catch (std::exception& e) {
72160       {
72161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72162       };
72163     } catch (Dali::DaliException e) {
72164       {
72165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72166       };
72167     } catch (...) {
72168       {
72169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72170       };
72171     }
72172   }
72173
72174
72175   //argout typemap for const std::string&
72176
72177 }
72178
72179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72180   void * jresult ;
72181   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72182   Dali::Image result;
72183
72184   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72185   {
72186     try {
72187       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72188     } catch (std::out_of_range& e) {
72189       {
72190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72191       };
72192     } catch (std::exception& e) {
72193       {
72194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72195       };
72196     } catch (Dali::DaliException e) {
72197       {
72198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72199       };
72200     } catch (...) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72203       };
72204     }
72205   }
72206
72207   jresult = new Dali::Image((const Dali::Image &)result);
72208   return jresult;
72209 }
72210
72211
72212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72213   int jresult ;
72214   int result;
72215
72216   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72217   jresult = (int)result;
72218   return jresult;
72219 }
72220
72221
72222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72223   int jresult ;
72224   int result;
72225
72226   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72227   jresult = (int)result;
72228   return jresult;
72229 }
72230
72231
72232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72233   int jresult ;
72234   int result;
72235
72236   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72237   jresult = (int)result;
72238   return jresult;
72239 }
72240
72241
72242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72243   int jresult ;
72244   int result;
72245
72246   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72247   jresult = (int)result;
72248   return jresult;
72249 }
72250
72251
72252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72253   int jresult ;
72254   int result;
72255
72256   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72257   jresult = (int)result;
72258   return jresult;
72259 }
72260
72261
72262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72263   int jresult ;
72264   int result;
72265
72266   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72267   jresult = (int)result;
72268   return jresult;
72269 }
72270
72271
72272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72273   int jresult ;
72274   int result;
72275
72276   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72277   jresult = (int)result;
72278   return jresult;
72279 }
72280
72281
72282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72283   int jresult ;
72284   int result;
72285
72286   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72287   jresult = (int)result;
72288   return jresult;
72289 }
72290
72291
72292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72293   void * jresult ;
72294   Dali::Toolkit::Model3dView::Property *result = 0 ;
72295
72296   {
72297     try {
72298       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72299     } catch (std::out_of_range& e) {
72300       {
72301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72302       };
72303     } catch (std::exception& e) {
72304       {
72305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72306       };
72307     } catch (Dali::DaliException e) {
72308       {
72309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72310       };
72311     } catch (...) {
72312       {
72313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72314       };
72315     }
72316   }
72317
72318   jresult = (void *)result;
72319   return jresult;
72320 }
72321
72322
72323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72324   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72325
72326   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72327   {
72328     try {
72329       delete arg1;
72330     } catch (std::out_of_range& e) {
72331       {
72332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72333       };
72334     } catch (std::exception& e) {
72335       {
72336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72337       };
72338     } catch (Dali::DaliException e) {
72339       {
72340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72341       };
72342     } catch (...) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72345       };
72346     }
72347   }
72348
72349 }
72350
72351
72352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72353   void * jresult ;
72354   Dali::Toolkit::Model3dView result;
72355
72356   {
72357     try {
72358       result = Dali::Toolkit::Model3dView::New();
72359     } catch (std::out_of_range& e) {
72360       {
72361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72362       };
72363     } catch (std::exception& e) {
72364       {
72365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72366       };
72367     } catch (Dali::DaliException e) {
72368       {
72369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72374       };
72375     }
72376   }
72377
72378   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72379   return jresult;
72380 }
72381
72382
72383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72384   void * jresult ;
72385   std::string *arg1 = 0 ;
72386   std::string *arg2 = 0 ;
72387   std::string *arg3 = 0 ;
72388   Dali::Toolkit::Model3dView result;
72389
72390   if (!jarg1) {
72391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72392     return 0;
72393   }
72394   std::string arg1_str(jarg1);
72395   arg1 = &arg1_str;
72396   if (!jarg2) {
72397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72398     return 0;
72399   }
72400   std::string arg2_str(jarg2);
72401   arg2 = &arg2_str;
72402   if (!jarg3) {
72403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72404     return 0;
72405   }
72406   std::string arg3_str(jarg3);
72407   arg3 = &arg3_str;
72408   {
72409     try {
72410       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72411     } catch (std::out_of_range& e) {
72412       {
72413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72414       };
72415     } catch (std::exception& e) {
72416       {
72417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72418       };
72419     } catch (Dali::DaliException e) {
72420       {
72421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72422       };
72423     } catch (...) {
72424       {
72425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72426       };
72427     }
72428   }
72429
72430   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72431
72432   //argout typemap for const std::string&
72433
72434
72435   //argout typemap for const std::string&
72436
72437
72438   //argout typemap for const std::string&
72439
72440   return jresult;
72441 }
72442
72443
72444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72445   void * jresult ;
72446   Dali::Toolkit::Model3dView *result = 0 ;
72447
72448   {
72449     try {
72450       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72451     } catch (std::out_of_range& e) {
72452       {
72453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72454       };
72455     } catch (std::exception& e) {
72456       {
72457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72458       };
72459     } catch (Dali::DaliException e) {
72460       {
72461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72462       };
72463     } catch (...) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72466       };
72467     }
72468   }
72469
72470   jresult = (void *)result;
72471   return jresult;
72472 }
72473
72474
72475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72476   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72477
72478   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72479   {
72480     try {
72481       delete arg1;
72482     } catch (std::out_of_range& e) {
72483       {
72484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72485       };
72486     } catch (std::exception& e) {
72487       {
72488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72489       };
72490     } catch (Dali::DaliException e) {
72491       {
72492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72493       };
72494     } catch (...) {
72495       {
72496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72497       };
72498     }
72499   }
72500
72501 }
72502
72503
72504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72505   void * jresult ;
72506   Dali::Toolkit::Model3dView *arg1 = 0 ;
72507   Dali::Toolkit::Model3dView *result = 0 ;
72508
72509   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72510   if (!arg1) {
72511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72512     return 0;
72513   }
72514   {
72515     try {
72516       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72517     } catch (std::out_of_range& e) {
72518       {
72519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72520       };
72521     } catch (std::exception& e) {
72522       {
72523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72524       };
72525     } catch (Dali::DaliException e) {
72526       {
72527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72528       };
72529     } catch (...) {
72530       {
72531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72532       };
72533     }
72534   }
72535
72536   jresult = (void *)result;
72537   return jresult;
72538 }
72539
72540
72541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72542   void * jresult ;
72543   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72544   Dali::Toolkit::Model3dView *arg2 = 0 ;
72545   Dali::Toolkit::Model3dView *result = 0 ;
72546
72547   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72548   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72549   if (!arg2) {
72550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72551     return 0;
72552   }
72553   {
72554     try {
72555       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72556     } catch (std::out_of_range& e) {
72557       {
72558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72559       };
72560     } catch (std::exception& e) {
72561       {
72562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72563       };
72564     } catch (Dali::DaliException e) {
72565       {
72566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72567       };
72568     } catch (...) {
72569       {
72570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72571       };
72572     }
72573   }
72574
72575   jresult = (void *)result;
72576   return jresult;
72577 }
72578
72579
72580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72581   void * jresult ;
72582   Dali::BaseHandle arg1 ;
72583   Dali::BaseHandle *argp1 ;
72584   Dali::Toolkit::Model3dView result;
72585
72586   argp1 = (Dali::BaseHandle *)jarg1;
72587   if (!argp1) {
72588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72589     return 0;
72590   }
72591   arg1 = *argp1;
72592   {
72593     try {
72594       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72595     } catch (std::out_of_range& e) {
72596       {
72597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72598       };
72599     } catch (std::exception& e) {
72600       {
72601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72602       };
72603     } catch (Dali::DaliException e) {
72604       {
72605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72606       };
72607     } catch (...) {
72608       {
72609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72610       };
72611     }
72612   }
72613
72614   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72615   return jresult;
72616 }
72617
72618
72619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72620   int jresult ;
72621   int result;
72622
72623   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72624   jresult = (int)result;
72625   return jresult;
72626 }
72627
72628
72629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72630   int jresult ;
72631   int result;
72632
72633   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72634   jresult = (int)result;
72635   return jresult;
72636 }
72637
72638
72639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72640   int jresult ;
72641   int result;
72642
72643   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72644   jresult = (int)result;
72645   return jresult;
72646 }
72647
72648
72649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72650   int jresult ;
72651   int result;
72652
72653   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72654   jresult = (int)result;
72655   return jresult;
72656 }
72657
72658
72659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72660   int jresult ;
72661   int result;
72662
72663   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72664   jresult = (int)result;
72665   return jresult;
72666 }
72667
72668
72669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72670   int jresult ;
72671   int result;
72672
72673   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72674   jresult = (int)result;
72675   return jresult;
72676 }
72677
72678
72679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72680   int jresult ;
72681   int result;
72682
72683   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72684   jresult = (int)result;
72685   return jresult;
72686 }
72687
72688
72689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72690   int jresult ;
72691   int result;
72692
72693   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72694   jresult = (int)result;
72695   return jresult;
72696 }
72697
72698
72699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72700   int jresult ;
72701   int result;
72702
72703   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72704   jresult = (int)result;
72705   return jresult;
72706 }
72707
72708
72709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72710   void * jresult ;
72711   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72712
72713   {
72714     try {
72715       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72723       };
72724     } catch (Dali::DaliException e) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72727       };
72728     } catch (...) {
72729       {
72730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72731       };
72732     }
72733   }
72734
72735   jresult = (void *)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72741   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72742
72743   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72744   {
72745     try {
72746       delete arg1;
72747     } catch (std::out_of_range& e) {
72748       {
72749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72750       };
72751     } catch (std::exception& e) {
72752       {
72753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72754       };
72755     } catch (Dali::DaliException e) {
72756       {
72757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72758       };
72759     } catch (...) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72762       };
72763     }
72764   }
72765
72766 }
72767
72768
72769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72770   void * jresult ;
72771   Dali::Toolkit::ScrollBar *result = 0 ;
72772
72773   {
72774     try {
72775       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72776     } catch (std::out_of_range& e) {
72777       {
72778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72779       };
72780     } catch (std::exception& e) {
72781       {
72782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72783       };
72784     } catch (Dali::DaliException e) {
72785       {
72786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72787       };
72788     } catch (...) {
72789       {
72790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72791       };
72792     }
72793   }
72794
72795   jresult = (void *)result;
72796   return jresult;
72797 }
72798
72799
72800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72801   void * jresult ;
72802   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72803   Dali::Toolkit::ScrollBar *result = 0 ;
72804
72805   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72806   if (!arg1) {
72807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72808     return 0;
72809   }
72810   {
72811     try {
72812       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72813     } catch (std::out_of_range& e) {
72814       {
72815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72816       };
72817     } catch (std::exception& e) {
72818       {
72819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72820       };
72821     } catch (Dali::DaliException e) {
72822       {
72823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72824       };
72825     } catch (...) {
72826       {
72827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72828       };
72829     }
72830   }
72831
72832   jresult = (void *)result;
72833   return jresult;
72834 }
72835
72836
72837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72838   void * jresult ;
72839   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72840   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72841   Dali::Toolkit::ScrollBar *result = 0 ;
72842
72843   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72844   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72845   if (!arg2) {
72846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72847     return 0;
72848   }
72849   {
72850     try {
72851       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72852     } catch (std::out_of_range& e) {
72853       {
72854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72855       };
72856     } catch (std::exception& e) {
72857       {
72858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72859       };
72860     } catch (Dali::DaliException e) {
72861       {
72862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72863       };
72864     } catch (...) {
72865       {
72866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72867       };
72868     }
72869   }
72870
72871   jresult = (void *)result;
72872   return jresult;
72873 }
72874
72875
72876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72877   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72878
72879   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72880   {
72881     try {
72882       delete arg1;
72883     } catch (std::out_of_range& e) {
72884       {
72885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72886       };
72887     } catch (std::exception& e) {
72888       {
72889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72890       };
72891     } catch (Dali::DaliException e) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72894       };
72895     } catch (...) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72898       };
72899     }
72900   }
72901
72902 }
72903
72904
72905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72906   void * jresult ;
72907   Dali::Toolkit::ScrollBar::Direction arg1 ;
72908   Dali::Toolkit::ScrollBar result;
72909
72910   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72911   {
72912     try {
72913       result = Dali::Toolkit::ScrollBar::New(arg1);
72914     } catch (std::out_of_range& e) {
72915       {
72916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72917       };
72918     } catch (std::exception& e) {
72919       {
72920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72921       };
72922     } catch (Dali::DaliException e) {
72923       {
72924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72925       };
72926     } catch (...) {
72927       {
72928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72929       };
72930     }
72931   }
72932
72933   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72934   return jresult;
72935 }
72936
72937
72938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72939   void * jresult ;
72940   Dali::Toolkit::ScrollBar result;
72941
72942   {
72943     try {
72944       result = Dali::Toolkit::ScrollBar::New();
72945     } catch (std::out_of_range& e) {
72946       {
72947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72948       };
72949     } catch (std::exception& e) {
72950       {
72951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72952       };
72953     } catch (Dali::DaliException e) {
72954       {
72955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72956       };
72957     } catch (...) {
72958       {
72959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72960       };
72961     }
72962   }
72963
72964   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72965   return jresult;
72966 }
72967
72968
72969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72970   void * jresult ;
72971   Dali::BaseHandle arg1 ;
72972   Dali::BaseHandle *argp1 ;
72973   Dali::Toolkit::ScrollBar result;
72974
72975   argp1 = (Dali::BaseHandle *)jarg1;
72976   if (!argp1) {
72977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72978     return 0;
72979   }
72980   arg1 = *argp1;
72981   {
72982     try {
72983       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72984     } catch (std::out_of_range& e) {
72985       {
72986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72987       };
72988     } catch (std::exception& e) {
72989       {
72990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72991       };
72992     } catch (Dali::DaliException e) {
72993       {
72994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72995       };
72996     } catch (...) {
72997       {
72998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72999       };
73000     }
73001   }
73002
73003   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73004   return jresult;
73005 }
73006
73007
73008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73009   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73010   Dali::Handle arg2 ;
73011   Dali::Property::Index arg3 ;
73012   Dali::Property::Index arg4 ;
73013   Dali::Property::Index arg5 ;
73014   Dali::Property::Index arg6 ;
73015   Dali::Handle *argp2 ;
73016
73017   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73018   argp2 = (Dali::Handle *)jarg2;
73019   if (!argp2) {
73020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73021     return ;
73022   }
73023   arg2 = *argp2;
73024   arg3 = (Dali::Property::Index)jarg3;
73025   arg4 = (Dali::Property::Index)jarg4;
73026   arg5 = (Dali::Property::Index)jarg5;
73027   arg6 = (Dali::Property::Index)jarg6;
73028   {
73029     try {
73030       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73031     } catch (std::out_of_range& e) {
73032       {
73033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73034       };
73035     } catch (std::exception& e) {
73036       {
73037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73038       };
73039     } catch (Dali::DaliException e) {
73040       {
73041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73042       };
73043     } catch (...) {
73044       {
73045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73046       };
73047     }
73048   }
73049
73050 }
73051
73052
73053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73054   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73055   Dali::Actor arg2 ;
73056   Dali::Actor *argp2 ;
73057
73058   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73059   argp2 = (Dali::Actor *)jarg2;
73060   if (!argp2) {
73061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73062     return ;
73063   }
73064   arg2 = *argp2;
73065   {
73066     try {
73067       (arg1)->SetScrollIndicator(arg2);
73068     } catch (std::out_of_range& e) {
73069       {
73070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73071       };
73072     } catch (std::exception& e) {
73073       {
73074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73075       };
73076     } catch (Dali::DaliException e) {
73077       {
73078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73079       };
73080     } catch (...) {
73081       {
73082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73083       };
73084     }
73085   }
73086
73087 }
73088
73089
73090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73091   void * jresult ;
73092   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73093   Dali::Actor result;
73094
73095   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73096   {
73097     try {
73098       result = (arg1)->GetScrollIndicator();
73099     } catch (std::out_of_range& e) {
73100       {
73101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73102       };
73103     } catch (std::exception& e) {
73104       {
73105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73106       };
73107     } catch (Dali::DaliException e) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73110       };
73111     } catch (...) {
73112       {
73113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73114       };
73115     }
73116   }
73117
73118   jresult = new Dali::Actor((const Dali::Actor &)result);
73119   return jresult;
73120 }
73121
73122
73123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73124   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73125   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73126
73127   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73128   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73129   if (!arg2) {
73130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73131     return ;
73132   }
73133   {
73134     try {
73135       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73136     } catch (std::out_of_range& e) {
73137       {
73138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73139       };
73140     } catch (std::exception& e) {
73141       {
73142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73143       };
73144     } catch (Dali::DaliException e) {
73145       {
73146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73147       };
73148     } catch (...) {
73149       {
73150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73151       };
73152     }
73153   }
73154
73155 }
73156
73157
73158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73159   void * jresult ;
73160   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73161
73162   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73163   {
73164     try {
73165       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()));
73166     } catch (std::out_of_range& e) {
73167       {
73168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73169       };
73170     } catch (std::exception& e) {
73171       {
73172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73173       };
73174     } catch (...) {
73175       {
73176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73177       };
73178     }
73179   }
73180   return jresult;
73181 }
73182
73183
73184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73185   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73186   Dali::Toolkit::ScrollBar::Direction arg2 ;
73187
73188   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73189   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73190   {
73191     try {
73192       (arg1)->SetScrollDirection(arg2);
73193     } catch (std::out_of_range& e) {
73194       {
73195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73196       };
73197     } catch (std::exception& e) {
73198       {
73199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73200       };
73201     } catch (Dali::DaliException e) {
73202       {
73203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73204       };
73205     } catch (...) {
73206       {
73207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73208       };
73209     }
73210   }
73211
73212 }
73213
73214
73215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73216   int jresult ;
73217   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73218   Dali::Toolkit::ScrollBar::Direction result;
73219
73220   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73221   {
73222     try {
73223       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73224     } catch (std::out_of_range& e) {
73225       {
73226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73227       };
73228     } catch (std::exception& e) {
73229       {
73230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73231       };
73232     } catch (Dali::DaliException e) {
73233       {
73234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73235       };
73236     } catch (...) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73239       };
73240     }
73241   }
73242
73243   jresult = (int)result;
73244   return jresult;
73245 }
73246
73247
73248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73249   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73250   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73251
73252   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73253   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73254   {
73255     try {
73256       (arg1)->SetIndicatorHeightPolicy(arg2);
73257     } catch (std::out_of_range& e) {
73258       {
73259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73260       };
73261     } catch (std::exception& e) {
73262       {
73263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73264       };
73265     } catch (Dali::DaliException e) {
73266       {
73267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73268       };
73269     } catch (...) {
73270       {
73271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73272       };
73273     }
73274   }
73275
73276 }
73277
73278
73279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73280   int jresult ;
73281   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73282   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73283
73284   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73285   {
73286     try {
73287       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73288     } catch (std::out_of_range& e) {
73289       {
73290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (std::exception& e) {
73293       {
73294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73295       };
73296     } catch (Dali::DaliException e) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73299       };
73300     } catch (...) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73303       };
73304     }
73305   }
73306
73307   jresult = (int)result;
73308   return jresult;
73309 }
73310
73311
73312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73313   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73314   float arg2 ;
73315
73316   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73317   arg2 = (float)jarg2;
73318   {
73319     try {
73320       (arg1)->SetIndicatorFixedHeight(arg2);
73321     } catch (std::out_of_range& e) {
73322       {
73323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73324       };
73325     } catch (std::exception& e) {
73326       {
73327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73328       };
73329     } catch (Dali::DaliException e) {
73330       {
73331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73332       };
73333     } catch (...) {
73334       {
73335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73336       };
73337     }
73338   }
73339
73340 }
73341
73342
73343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73344   float jresult ;
73345   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73346   float result;
73347
73348   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73349   {
73350     try {
73351       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73352     } catch (std::out_of_range& e) {
73353       {
73354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73355       };
73356     } catch (std::exception& e) {
73357       {
73358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (Dali::DaliException e) {
73361       {
73362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73363       };
73364     } catch (...) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73367       };
73368     }
73369   }
73370
73371   jresult = result;
73372   return jresult;
73373 }
73374
73375
73376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73377   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73378   float arg2 ;
73379
73380   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73381   arg2 = (float)jarg2;
73382   {
73383     try {
73384       (arg1)->SetIndicatorShowDuration(arg2);
73385     } catch (std::out_of_range& e) {
73386       {
73387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73388       };
73389     } catch (std::exception& e) {
73390       {
73391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73392       };
73393     } catch (Dali::DaliException e) {
73394       {
73395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73396       };
73397     } catch (...) {
73398       {
73399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73400       };
73401     }
73402   }
73403
73404 }
73405
73406
73407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73408   float jresult ;
73409   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73410   float result;
73411
73412   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73413   {
73414     try {
73415       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73416     } catch (std::out_of_range& e) {
73417       {
73418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73419       };
73420     } catch (std::exception& e) {
73421       {
73422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73423       };
73424     } catch (Dali::DaliException e) {
73425       {
73426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73427       };
73428     } catch (...) {
73429       {
73430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73431       };
73432     }
73433   }
73434
73435   jresult = result;
73436   return jresult;
73437 }
73438
73439
73440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73441   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73442   float arg2 ;
73443
73444   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73445   arg2 = (float)jarg2;
73446   {
73447     try {
73448       (arg1)->SetIndicatorHideDuration(arg2);
73449     } catch (std::out_of_range& e) {
73450       {
73451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73452       };
73453     } catch (std::exception& e) {
73454       {
73455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73456       };
73457     } catch (Dali::DaliException e) {
73458       {
73459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73460       };
73461     } catch (...) {
73462       {
73463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73464       };
73465     }
73466   }
73467
73468 }
73469
73470
73471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73472   float jresult ;
73473   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73474   float result;
73475
73476   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73477   {
73478     try {
73479       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73480     } catch (std::out_of_range& e) {
73481       {
73482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73483       };
73484     } catch (std::exception& e) {
73485       {
73486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73487       };
73488     } catch (Dali::DaliException e) {
73489       {
73490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73491       };
73492     } catch (...) {
73493       {
73494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73495       };
73496     }
73497   }
73498
73499   jresult = result;
73500   return jresult;
73501 }
73502
73503
73504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73505   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73506
73507   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73508   {
73509     try {
73510       (arg1)->ShowIndicator();
73511     } catch (std::out_of_range& e) {
73512       {
73513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73514       };
73515     } catch (std::exception& e) {
73516       {
73517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73518       };
73519     } catch (Dali::DaliException e) {
73520       {
73521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73522       };
73523     } catch (...) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73526       };
73527     }
73528   }
73529
73530 }
73531
73532
73533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73534   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73535
73536   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73537   {
73538     try {
73539       (arg1)->HideIndicator();
73540     } catch (std::out_of_range& e) {
73541       {
73542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73543       };
73544     } catch (std::exception& e) {
73545       {
73546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73547       };
73548     } catch (Dali::DaliException e) {
73549       {
73550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73551       };
73552     } catch (...) {
73553       {
73554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73555       };
73556     }
73557   }
73558
73559 }
73560
73561
73562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73563   void * jresult ;
73564   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73565   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73566
73567   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73568   {
73569     try {
73570       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73571     } catch (std::out_of_range& e) {
73572       {
73573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73574       };
73575     } catch (std::exception& e) {
73576       {
73577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73578       };
73579     } catch (Dali::DaliException e) {
73580       {
73581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73582       };
73583     } catch (...) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73586       };
73587     }
73588   }
73589
73590   jresult = (void *)result;
73591   return jresult;
73592 }
73593
73594
73595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73596   void * jresult ;
73597   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73598   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73599
73600   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73601   {
73602     try {
73603       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73604     } catch (std::out_of_range& e) {
73605       {
73606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73607       };
73608     } catch (std::exception& e) {
73609       {
73610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73611       };
73612     } catch (Dali::DaliException e) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73615       };
73616     } catch (...) {
73617       {
73618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73619       };
73620     }
73621   }
73622
73623   jresult = (void *)result;
73624   return jresult;
73625 }
73626
73627
73628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73629   int jresult ;
73630   int result;
73631
73632   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73633   jresult = (int)result;
73634   return jresult;
73635 }
73636
73637
73638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73639   int jresult ;
73640   int result;
73641
73642   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73643   jresult = (int)result;
73644   return jresult;
73645 }
73646
73647
73648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73649   int jresult ;
73650   int result;
73651
73652   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73653   jresult = (int)result;
73654   return jresult;
73655 }
73656
73657
73658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73659   int jresult ;
73660   int result;
73661
73662   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73663   jresult = (int)result;
73664   return jresult;
73665 }
73666
73667
73668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73669   int jresult ;
73670   int result;
73671
73672   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73673   jresult = (int)result;
73674   return jresult;
73675 }
73676
73677
73678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73679   int jresult ;
73680   int result;
73681
73682   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73683   jresult = (int)result;
73684   return jresult;
73685 }
73686
73687
73688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73689   int jresult ;
73690   int result;
73691
73692   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73693   jresult = (int)result;
73694   return jresult;
73695 }
73696
73697
73698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73699   int jresult ;
73700   int result;
73701
73702   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73703   jresult = (int)result;
73704   return jresult;
73705 }
73706
73707
73708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73709   int jresult ;
73710   int result;
73711
73712   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73713   jresult = (int)result;
73714   return jresult;
73715 }
73716
73717
73718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73719   int jresult ;
73720   int result;
73721
73722   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73723   jresult = (int)result;
73724   return jresult;
73725 }
73726
73727
73728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73729   int jresult ;
73730   int result;
73731
73732   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73733   jresult = (int)result;
73734   return jresult;
73735 }
73736
73737
73738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73739   int jresult ;
73740   int result;
73741
73742   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73743   jresult = (int)result;
73744   return jresult;
73745 }
73746
73747
73748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73749   int jresult ;
73750   int result;
73751
73752   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73753   jresult = (int)result;
73754   return jresult;
73755 }
73756
73757
73758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73759   int jresult ;
73760   int result;
73761
73762   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73763   jresult = (int)result;
73764   return jresult;
73765 }
73766
73767
73768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73769   void * jresult ;
73770   Dali::Toolkit::Scrollable::Property *result = 0 ;
73771
73772   {
73773     try {
73774       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73775     } catch (std::out_of_range& e) {
73776       {
73777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73778       };
73779     } catch (std::exception& e) {
73780       {
73781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73782       };
73783     } catch (Dali::DaliException e) {
73784       {
73785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73786       };
73787     } catch (...) {
73788       {
73789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73790       };
73791     }
73792   }
73793
73794   jresult = (void *)result;
73795   return jresult;
73796 }
73797
73798
73799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73800   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73801
73802   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73803   {
73804     try {
73805       delete arg1;
73806     } catch (std::out_of_range& e) {
73807       {
73808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73809       };
73810     } catch (std::exception& e) {
73811       {
73812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73813       };
73814     } catch (Dali::DaliException e) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73817       };
73818     } catch (...) {
73819       {
73820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73821       };
73822     }
73823   }
73824
73825 }
73826
73827
73828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73829   void * jresult ;
73830   Dali::Toolkit::Scrollable *result = 0 ;
73831
73832   {
73833     try {
73834       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73835     } catch (std::out_of_range& e) {
73836       {
73837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73838       };
73839     } catch (std::exception& e) {
73840       {
73841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73842       };
73843     } catch (Dali::DaliException e) {
73844       {
73845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73846       };
73847     } catch (...) {
73848       {
73849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73850       };
73851     }
73852   }
73853
73854   jresult = (void *)result;
73855   return jresult;
73856 }
73857
73858
73859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73860   void * jresult ;
73861   Dali::Toolkit::Scrollable *arg1 = 0 ;
73862   Dali::Toolkit::Scrollable *result = 0 ;
73863
73864   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73865   if (!arg1) {
73866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73867     return 0;
73868   }
73869   {
73870     try {
73871       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73872     } catch (std::out_of_range& e) {
73873       {
73874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73875       };
73876     } catch (std::exception& e) {
73877       {
73878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73879       };
73880     } catch (Dali::DaliException e) {
73881       {
73882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73883       };
73884     } catch (...) {
73885       {
73886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73887       };
73888     }
73889   }
73890
73891   jresult = (void *)result;
73892   return jresult;
73893 }
73894
73895
73896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73897   void * jresult ;
73898   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73899   Dali::Toolkit::Scrollable *arg2 = 0 ;
73900   Dali::Toolkit::Scrollable *result = 0 ;
73901
73902   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73903   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73904   if (!arg2) {
73905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73906     return 0;
73907   }
73908   {
73909     try {
73910       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73911     } catch (std::out_of_range& e) {
73912       {
73913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73914       };
73915     } catch (std::exception& e) {
73916       {
73917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (Dali::DaliException e) {
73920       {
73921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73922       };
73923     } catch (...) {
73924       {
73925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73926       };
73927     }
73928   }
73929
73930   jresult = (void *)result;
73931   return jresult;
73932 }
73933
73934
73935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73936   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73937
73938   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73939   {
73940     try {
73941       delete arg1;
73942     } catch (std::out_of_range& e) {
73943       {
73944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73945       };
73946     } catch (std::exception& e) {
73947       {
73948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73949       };
73950     } catch (Dali::DaliException e) {
73951       {
73952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73953       };
73954     } catch (...) {
73955       {
73956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73957       };
73958     }
73959   }
73960
73961 }
73962
73963
73964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73965   void * jresult ;
73966   Dali::BaseHandle arg1 ;
73967   Dali::BaseHandle *argp1 ;
73968   Dali::Toolkit::Scrollable result;
73969
73970   argp1 = (Dali::BaseHandle *)jarg1;
73971   if (!argp1) {
73972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73973     return 0;
73974   }
73975   arg1 = *argp1;
73976   {
73977     try {
73978       result = Dali::Toolkit::Scrollable::DownCast(arg1);
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 = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73999   return jresult;
74000 }
74001
74002
74003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74004   unsigned int jresult ;
74005   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74006   bool result;
74007
74008   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74009   {
74010     try {
74011       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74012     } catch (std::out_of_range& e) {
74013       {
74014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74015       };
74016     } catch (std::exception& e) {
74017       {
74018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74019       };
74020     } catch (Dali::DaliException e) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74023       };
74024     } catch (...) {
74025       {
74026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74027       };
74028     }
74029   }
74030
74031   jresult = result;
74032   return jresult;
74033 }
74034
74035
74036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74037   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74038   bool arg2 ;
74039
74040   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74041   arg2 = jarg2 ? true : false;
74042   {
74043     try {
74044       (arg1)->SetOvershootEnabled(arg2);
74045     } catch (std::out_of_range& e) {
74046       {
74047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74048       };
74049     } catch (std::exception& e) {
74050       {
74051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74052       };
74053     } catch (Dali::DaliException e) {
74054       {
74055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74056       };
74057     } catch (...) {
74058       {
74059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74060       };
74061     }
74062   }
74063
74064 }
74065
74066
74067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74068   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74069   Dali::Vector4 *arg2 = 0 ;
74070
74071   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74072   arg2 = (Dali::Vector4 *)jarg2;
74073   if (!arg2) {
74074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74075     return ;
74076   }
74077   {
74078     try {
74079       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74080     } catch (std::out_of_range& e) {
74081       {
74082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74083       };
74084     } catch (std::exception& e) {
74085       {
74086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74087       };
74088     } catch (Dali::DaliException e) {
74089       {
74090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74091       };
74092     } catch (...) {
74093       {
74094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74095       };
74096     }
74097   }
74098
74099 }
74100
74101
74102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74103   void * jresult ;
74104   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74105   Dali::Vector4 result;
74106
74107   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74108   {
74109     try {
74110       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74111     } catch (std::out_of_range& e) {
74112       {
74113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74114       };
74115     } catch (std::exception& e) {
74116       {
74117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74118       };
74119     } catch (Dali::DaliException e) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74122       };
74123     } catch (...) {
74124       {
74125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74126       };
74127     }
74128   }
74129
74130   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74131   return jresult;
74132 }
74133
74134
74135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74136   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74137   float arg2 ;
74138
74139   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74140   arg2 = (float)jarg2;
74141   {
74142     try {
74143       (arg1)->SetOvershootAnimationSpeed(arg2);
74144     } catch (std::out_of_range& e) {
74145       {
74146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74147       };
74148     } catch (std::exception& e) {
74149       {
74150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74151       };
74152     } catch (Dali::DaliException e) {
74153       {
74154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74155       };
74156     } catch (...) {
74157       {
74158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74159       };
74160     }
74161   }
74162
74163 }
74164
74165
74166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74167   float jresult ;
74168   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74169   float result;
74170
74171   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74172   {
74173     try {
74174       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74175     } catch (std::out_of_range& e) {
74176       {
74177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74178       };
74179     } catch (std::exception& e) {
74180       {
74181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74182       };
74183     } catch (Dali::DaliException e) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74186       };
74187     } catch (...) {
74188       {
74189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74190       };
74191     }
74192   }
74193
74194   jresult = result;
74195   return jresult;
74196 }
74197
74198
74199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74200   void * jresult ;
74201   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74202   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74203
74204   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74205   {
74206     try {
74207       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74208     } catch (std::out_of_range& e) {
74209       {
74210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74211       };
74212     } catch (std::exception& e) {
74213       {
74214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74215       };
74216     } catch (Dali::DaliException e) {
74217       {
74218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74219       };
74220     } catch (...) {
74221       {
74222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74223       };
74224     }
74225   }
74226
74227   jresult = (void *)result;
74228   return jresult;
74229 }
74230
74231
74232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74233   void * jresult ;
74234   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74235   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74236
74237   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74238   {
74239     try {
74240       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74241     } catch (std::out_of_range& e) {
74242       {
74243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74244       };
74245     } catch (std::exception& e) {
74246       {
74247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74248       };
74249     } catch (Dali::DaliException e) {
74250       {
74251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74252       };
74253     } catch (...) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74256       };
74257     }
74258   }
74259
74260   jresult = (void *)result;
74261   return jresult;
74262 }
74263
74264
74265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74266   void * jresult ;
74267   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74268   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74269
74270   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74271   {
74272     try {
74273       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
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 unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74299   unsigned int jresult ;
74300   Dali::Toolkit::ControlOrientation::Type arg1 ;
74301   bool result;
74302
74303   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74304   {
74305     try {
74306       result = (bool)Dali::Toolkit::IsVertical(arg1);
74307     } catch (std::out_of_range& e) {
74308       {
74309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74310       };
74311     } catch (std::exception& e) {
74312       {
74313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74314       };
74315     } catch (Dali::DaliException e) {
74316       {
74317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74318       };
74319     } catch (...) {
74320       {
74321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74322       };
74323     }
74324   }
74325
74326   jresult = result;
74327   return jresult;
74328 }
74329
74330
74331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74332   unsigned int jresult ;
74333   Dali::Toolkit::ControlOrientation::Type arg1 ;
74334   bool result;
74335
74336   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74337   {
74338     try {
74339       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74340     } catch (std::out_of_range& e) {
74341       {
74342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74343       };
74344     } catch (std::exception& e) {
74345       {
74346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74347       };
74348     } catch (Dali::DaliException e) {
74349       {
74350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74351       };
74352     } catch (...) {
74353       {
74354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74355       };
74356     }
74357   }
74358
74359   jresult = result;
74360   return jresult;
74361 }
74362
74363
74364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74365   void * jresult ;
74366   unsigned int arg1 ;
74367   unsigned int arg2 ;
74368   Dali::Toolkit::ItemRange *result = 0 ;
74369
74370   arg1 = (unsigned int)jarg1;
74371   arg2 = (unsigned int)jarg2;
74372   {
74373     try {
74374       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74375     } catch (std::out_of_range& e) {
74376       {
74377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74378       };
74379     } catch (std::exception& e) {
74380       {
74381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74382       };
74383     } catch (Dali::DaliException e) {
74384       {
74385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74386       };
74387     } catch (...) {
74388       {
74389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74390       };
74391     }
74392   }
74393
74394   jresult = (void *)result;
74395   return jresult;
74396 }
74397
74398
74399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74400   void * jresult ;
74401   Dali::Toolkit::ItemRange *arg1 = 0 ;
74402   Dali::Toolkit::ItemRange *result = 0 ;
74403
74404   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74405   if (!arg1) {
74406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74407     return 0;
74408   }
74409   {
74410     try {
74411       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74412     } catch (std::out_of_range& e) {
74413       {
74414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74415       };
74416     } catch (std::exception& e) {
74417       {
74418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74419       };
74420     } catch (Dali::DaliException e) {
74421       {
74422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74423       };
74424     } catch (...) {
74425       {
74426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74427       };
74428     }
74429   }
74430
74431   jresult = (void *)result;
74432   return jresult;
74433 }
74434
74435
74436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74437   void * jresult ;
74438   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74439   Dali::Toolkit::ItemRange *arg2 = 0 ;
74440   Dali::Toolkit::ItemRange *result = 0 ;
74441
74442   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74443   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74444   if (!arg2) {
74445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74446     return 0;
74447   }
74448   {
74449     try {
74450       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74451     } catch (std::out_of_range& e) {
74452       {
74453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74454       };
74455     } catch (std::exception& e) {
74456       {
74457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74458       };
74459     } catch (Dali::DaliException e) {
74460       {
74461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74462       };
74463     } catch (...) {
74464       {
74465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74466       };
74467     }
74468   }
74469
74470   jresult = (void *)result;
74471   return jresult;
74472 }
74473
74474
74475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74476   unsigned int jresult ;
74477   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74478   unsigned int arg2 ;
74479   bool result;
74480
74481   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74482   arg2 = (unsigned int)jarg2;
74483   {
74484     try {
74485       result = (bool)(arg1)->Within(arg2);
74486     } catch (std::out_of_range& e) {
74487       {
74488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (std::exception& e) {
74491       {
74492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74493       };
74494     } catch (Dali::DaliException e) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74497       };
74498     } catch (...) {
74499       {
74500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74501       };
74502     }
74503   }
74504
74505   jresult = result;
74506   return jresult;
74507 }
74508
74509
74510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74511   void * jresult ;
74512   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74513   Dali::Toolkit::ItemRange *arg2 = 0 ;
74514   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74515
74516   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74517   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74518   if (!arg2) {
74519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74520     return 0;
74521   }
74522   {
74523     try {
74524       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74525     } catch (std::out_of_range& e) {
74526       {
74527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74528       };
74529     } catch (std::exception& e) {
74530       {
74531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74532       };
74533     } catch (Dali::DaliException e) {
74534       {
74535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74536       };
74537     } catch (...) {
74538       {
74539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74540       };
74541     }
74542   }
74543
74544   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74545   return jresult;
74546 }
74547
74548
74549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74550   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74551   unsigned int arg2 ;
74552
74553   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74554   arg2 = (unsigned int)jarg2;
74555   if (arg1) (arg1)->begin = arg2;
74556 }
74557
74558
74559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74560   unsigned int jresult ;
74561   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74562   unsigned int result;
74563
74564   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74565   result = (unsigned int) ((arg1)->begin);
74566   jresult = result;
74567   return jresult;
74568 }
74569
74570
74571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74572   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74573   unsigned int arg2 ;
74574
74575   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74576   arg2 = (unsigned int)jarg2;
74577   if (arg1) (arg1)->end = arg2;
74578 }
74579
74580
74581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74582   unsigned int jresult ;
74583   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74584   unsigned int result;
74585
74586   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74587   result = (unsigned int) ((arg1)->end);
74588   jresult = result;
74589   return jresult;
74590 }
74591
74592
74593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74594   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74595
74596   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74597   {
74598     try {
74599       delete arg1;
74600     } catch (std::out_of_range& e) {
74601       {
74602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74603       };
74604     } catch (std::exception& e) {
74605       {
74606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74607       };
74608     } catch (Dali::DaliException e) {
74609       {
74610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74611       };
74612     } catch (...) {
74613       {
74614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74615       };
74616     }
74617   }
74618
74619 }
74620
74621
74622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74623   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74624
74625   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74626   {
74627     try {
74628       delete arg1;
74629     } catch (std::out_of_range& e) {
74630       {
74631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74632       };
74633     } catch (std::exception& e) {
74634       {
74635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74636       };
74637     } catch (Dali::DaliException e) {
74638       {
74639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74640       };
74641     } catch (...) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74644       };
74645     }
74646   }
74647
74648 }
74649
74650
74651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74652   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74653   Dali::Toolkit::ControlOrientation::Type arg2 ;
74654
74655   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74656   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74657   {
74658     try {
74659       (arg1)->SetOrientation(arg2);
74660     } catch (std::out_of_range& e) {
74661       {
74662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74663       };
74664     } catch (std::exception& e) {
74665       {
74666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74667       };
74668     } catch (Dali::DaliException e) {
74669       {
74670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74671       };
74672     } catch (...) {
74673       {
74674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74675       };
74676     }
74677   }
74678
74679 }
74680
74681
74682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74683   int jresult ;
74684   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74685   Dali::Toolkit::ControlOrientation::Type result;
74686
74687   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74688   {
74689     try {
74690       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74691     } catch (std::out_of_range& e) {
74692       {
74693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74694       };
74695     } catch (std::exception& e) {
74696       {
74697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74698       };
74699     } catch (Dali::DaliException e) {
74700       {
74701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74702       };
74703     } catch (...) {
74704       {
74705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74706       };
74707     }
74708   }
74709
74710   jresult = (int)result;
74711   return jresult;
74712 }
74713
74714
74715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74716   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74717   Dali::Property::Map *arg2 = 0 ;
74718
74719   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74720   arg2 = (Dali::Property::Map *)jarg2;
74721   if (!arg2) {
74722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74723     return ;
74724   }
74725   {
74726     try {
74727       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74728     } catch (std::out_of_range& e) {
74729       {
74730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74731       };
74732     } catch (std::exception& e) {
74733       {
74734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74735       };
74736     } catch (Dali::DaliException e) {
74737       {
74738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74739       };
74740     } catch (...) {
74741       {
74742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74743       };
74744     }
74745   }
74746
74747 }
74748
74749
74750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74751   void * jresult ;
74752   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74753   Dali::Property::Map result;
74754
74755   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74756   {
74757     try {
74758       result = (arg1)->GetLayoutProperties();
74759     } catch (std::out_of_range& e) {
74760       {
74761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74762       };
74763     } catch (std::exception& e) {
74764       {
74765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74766       };
74767     } catch (Dali::DaliException e) {
74768       {
74769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74770       };
74771     } catch (...) {
74772       {
74773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74774       };
74775     }
74776   }
74777
74778   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74779   return jresult;
74780 }
74781
74782
74783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74784   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74785   unsigned int arg2 ;
74786   Dali::Vector3 *arg3 = 0 ;
74787   Dali::Vector3 *arg4 = 0 ;
74788
74789   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74790   arg2 = (unsigned int)jarg2;
74791   arg3 = (Dali::Vector3 *)jarg3;
74792   if (!arg3) {
74793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74794     return ;
74795   }
74796   arg4 = (Dali::Vector3 *)jarg4;
74797   if (!arg4) {
74798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74799     return ;
74800   }
74801   {
74802     try {
74803       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74804     } catch (std::out_of_range& e) {
74805       {
74806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74807       };
74808     } catch (std::exception& e) {
74809       {
74810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74811       };
74812     } catch (Dali::DaliException e) {
74813       {
74814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74815       };
74816     } catch (...) {
74817       {
74818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74819       };
74820     }
74821   }
74822
74823 }
74824
74825
74826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74827   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74828   Dali::Vector3 *arg2 = 0 ;
74829
74830   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74831   arg2 = (Dali::Vector3 *)jarg2;
74832   if (!arg2) {
74833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74834     return ;
74835   }
74836   {
74837     try {
74838       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74846       };
74847     } catch (Dali::DaliException e) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74850       };
74851     } catch (...) {
74852       {
74853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74854       };
74855     }
74856   }
74857
74858 }
74859
74860
74861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74862   float jresult ;
74863   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74864   unsigned int arg2 ;
74865   Dali::Vector3 arg3 ;
74866   Dali::Vector3 *argp3 ;
74867   float result;
74868
74869   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74870   arg2 = (unsigned int)jarg2;
74871   argp3 = (Dali::Vector3 *)jarg3;
74872   if (!argp3) {
74873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74874     return 0;
74875   }
74876   arg3 = *argp3;
74877   {
74878     try {
74879       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74880     } catch (std::out_of_range& e) {
74881       {
74882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74883       };
74884     } catch (std::exception& e) {
74885       {
74886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74887       };
74888     } catch (Dali::DaliException e) {
74889       {
74890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74891       };
74892     } catch (...) {
74893       {
74894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74895       };
74896     }
74897   }
74898
74899   jresult = result;
74900   return jresult;
74901 }
74902
74903
74904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74905   float jresult ;
74906   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74907   float arg2 ;
74908   float result;
74909
74910   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74911   arg2 = (float)jarg2;
74912   {
74913     try {
74914       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74915     } catch (std::out_of_range& e) {
74916       {
74917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74918       };
74919     } catch (std::exception& e) {
74920       {
74921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74922       };
74923     } catch (Dali::DaliException e) {
74924       {
74925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74926       };
74927     } catch (...) {
74928       {
74929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74930       };
74931     }
74932   }
74933
74934   jresult = result;
74935   return jresult;
74936 }
74937
74938
74939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74940   float jresult ;
74941   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74942   unsigned int arg2 ;
74943   float result;
74944
74945   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74946   arg2 = (unsigned int)jarg2;
74947   {
74948     try {
74949       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(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 = result;
74970   return jresult;
74971 }
74972
74973
74974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74975   void * jresult ;
74976   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74977   float arg2 ;
74978   Dali::Vector3 arg3 ;
74979   Dali::Vector3 *argp3 ;
74980   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74981
74982   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74983   arg2 = (float)jarg2;
74984   argp3 = (Dali::Vector3 *)jarg3;
74985   if (!argp3) {
74986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74987     return 0;
74988   }
74989   arg3 = *argp3;
74990   {
74991     try {
74992       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74993     } catch (std::out_of_range& e) {
74994       {
74995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74996       };
74997     } catch (std::exception& e) {
74998       {
74999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75000       };
75001     } catch (Dali::DaliException e) {
75002       {
75003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75004       };
75005     } catch (...) {
75006       {
75007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75008       };
75009     }
75010   }
75011
75012   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75013   return jresult;
75014 }
75015
75016
75017 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75018   float jresult ;
75019   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75020   int arg2 ;
75021   float arg3 ;
75022   Dali::Vector3 *arg4 = 0 ;
75023   float result;
75024
75025   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75026   arg2 = (int)jarg2;
75027   arg3 = (float)jarg3;
75028   arg4 = (Dali::Vector3 *)jarg4;
75029   if (!arg4) {
75030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75031     return 0;
75032   }
75033   {
75034     try {
75035       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75036     } catch (std::out_of_range& e) {
75037       {
75038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75039       };
75040     } catch (std::exception& e) {
75041       {
75042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (Dali::DaliException e) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75047       };
75048     } catch (...) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75051       };
75052     }
75053   }
75054
75055   jresult = result;
75056   return jresult;
75057 }
75058
75059
75060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75061   unsigned int jresult ;
75062   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75063   Dali::Vector3 arg2 ;
75064   Dali::Vector3 *argp2 ;
75065   unsigned int result;
75066
75067   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75068   argp2 = (Dali::Vector3 *)jarg2;
75069   if (!argp2) {
75070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75071     return 0;
75072   }
75073   arg2 = *argp2;
75074   {
75075     try {
75076       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75077     } catch (std::out_of_range& e) {
75078       {
75079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75080       };
75081     } catch (std::exception& e) {
75082       {
75083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75084       };
75085     } catch (Dali::DaliException e) {
75086       {
75087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75088       };
75089     } catch (...) {
75090       {
75091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75092       };
75093     }
75094   }
75095
75096   jresult = result;
75097   return jresult;
75098 }
75099
75100
75101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75102   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75103   unsigned int arg2 ;
75104   Dali::Vector3 *arg3 = 0 ;
75105   Dali::Vector3 *arg4 = 0 ;
75106
75107   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75108   arg2 = (unsigned int)jarg2;
75109   arg3 = (Dali::Vector3 *)jarg3;
75110   if (!arg3) {
75111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75112     return ;
75113   }
75114   arg4 = (Dali::Vector3 *)jarg4;
75115   if (!arg4) {
75116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75117     return ;
75118   }
75119   {
75120     try {
75121       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75122     } catch (std::out_of_range& e) {
75123       {
75124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75125       };
75126     } catch (std::exception& e) {
75127       {
75128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75129       };
75130     } catch (Dali::DaliException e) {
75131       {
75132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75133       };
75134     } catch (...) {
75135       {
75136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75137       };
75138     }
75139   }
75140
75141 }
75142
75143
75144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75145   void * jresult ;
75146   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75147   Dali::Degree result;
75148
75149   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75150   {
75151     try {
75152       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75153     } catch (std::out_of_range& e) {
75154       {
75155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75156       };
75157     } catch (std::exception& e) {
75158       {
75159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75160       };
75161     } catch (Dali::DaliException e) {
75162       {
75163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75164       };
75165     } catch (...) {
75166       {
75167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75168       };
75169     }
75170   }
75171
75172   jresult = new Dali::Degree((const Dali::Degree &)result);
75173   return jresult;
75174 }
75175
75176
75177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75178   float jresult ;
75179   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75180   float result;
75181
75182   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75183   {
75184     try {
75185       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75186     } catch (std::out_of_range& e) {
75187       {
75188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75189       };
75190     } catch (std::exception& e) {
75191       {
75192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75193       };
75194     } catch (Dali::DaliException e) {
75195       {
75196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75197       };
75198     } catch (...) {
75199       {
75200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75201       };
75202     }
75203   }
75204
75205   jresult = result;
75206   return jresult;
75207 }
75208
75209
75210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75211   float jresult ;
75212   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75213   float result;
75214
75215   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75216   {
75217     try {
75218       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75219     } catch (std::out_of_range& e) {
75220       {
75221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75222       };
75223     } catch (std::exception& e) {
75224       {
75225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75226       };
75227     } catch (Dali::DaliException e) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75230       };
75231     } catch (...) {
75232       {
75233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75234       };
75235     }
75236   }
75237
75238   jresult = result;
75239   return jresult;
75240 }
75241
75242
75243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75244   float jresult ;
75245   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75246   float result;
75247
75248   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75249   {
75250     try {
75251       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75252     } catch (std::out_of_range& e) {
75253       {
75254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75255       };
75256     } catch (std::exception& e) {
75257       {
75258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75259       };
75260     } catch (Dali::DaliException e) {
75261       {
75262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75263       };
75264     } catch (...) {
75265       {
75266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75267       };
75268     }
75269   }
75270
75271   jresult = result;
75272   return jresult;
75273 }
75274
75275
75276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75277   int jresult ;
75278   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75279   int arg2 ;
75280   int arg3 ;
75281   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75282   bool arg5 ;
75283   int result;
75284
75285   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75286   arg2 = (int)jarg2;
75287   arg3 = (int)jarg3;
75288   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75289   arg5 = jarg5 ? true : false;
75290   {
75291     try {
75292       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75293     } catch (std::out_of_range& e) {
75294       {
75295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75296       };
75297     } catch (std::exception& e) {
75298       {
75299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75300       };
75301     } catch (Dali::DaliException e) {
75302       {
75303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75304       };
75305     } catch (...) {
75306       {
75307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75308       };
75309     }
75310   }
75311
75312   jresult = result;
75313   return jresult;
75314 }
75315
75316
75317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75318   float jresult ;
75319   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75320   float result;
75321
75322   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75323   {
75324     try {
75325       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75326     } catch (std::out_of_range& e) {
75327       {
75328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75329       };
75330     } catch (std::exception& e) {
75331       {
75332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75333       };
75334     } catch (Dali::DaliException e) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75337       };
75338     } catch (...) {
75339       {
75340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75341       };
75342     }
75343   }
75344
75345   jresult = result;
75346   return jresult;
75347 }
75348
75349
75350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75351   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75352   Dali::Actor *arg2 = 0 ;
75353   int arg3 ;
75354   Dali::Vector3 *arg4 = 0 ;
75355   Dali::Actor *arg5 = 0 ;
75356
75357   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75358   arg2 = (Dali::Actor *)jarg2;
75359   if (!arg2) {
75360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75361     return ;
75362   }
75363   arg3 = (int)jarg3;
75364   arg4 = (Dali::Vector3 *)jarg4;
75365   if (!arg4) {
75366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75367     return ;
75368   }
75369   arg5 = (Dali::Actor *)jarg5;
75370   if (!arg5) {
75371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75372     return ;
75373   }
75374   {
75375     try {
75376       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75377     } catch (std::out_of_range& e) {
75378       {
75379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75380       };
75381     } catch (std::exception& e) {
75382       {
75383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75384       };
75385     } catch (Dali::DaliException e) {
75386       {
75387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75388       };
75389     } catch (...) {
75390       {
75391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75392       };
75393     }
75394   }
75395
75396 }
75397
75398
75399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75400   void * jresult ;
75401   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75402   int arg2 ;
75403   float arg3 ;
75404   Dali::Vector3 *arg4 = 0 ;
75405   Dali::Vector3 result;
75406
75407   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75408   arg2 = (int)jarg2;
75409   arg3 = (float)jarg3;
75410   arg4 = (Dali::Vector3 *)jarg4;
75411   if (!arg4) {
75412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75413     return 0;
75414   }
75415   {
75416     try {
75417       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75418     } catch (std::out_of_range& e) {
75419       {
75420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75421       };
75422     } catch (std::exception& e) {
75423       {
75424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75425       };
75426     } catch (Dali::DaliException e) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75429       };
75430     } catch (...) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75433       };
75434     }
75435   }
75436
75437   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75438   return jresult;
75439 }
75440
75441
75442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75443   void * jresult ;
75444   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75445   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75446
75447   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75448   {
75449     try {
75450       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75451     } catch (std::out_of_range& e) {
75452       {
75453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75454       };
75455     } catch (std::exception& e) {
75456       {
75457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75458       };
75459     } catch (Dali::DaliException e) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75462       };
75463     } catch (...) {
75464       {
75465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75466       };
75467     }
75468   }
75469
75470   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75471   return jresult;
75472 }
75473
75474
75475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75476   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75477
75478   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75479   {
75480     try {
75481       delete arg1;
75482     } catch (std::out_of_range& e) {
75483       {
75484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75485       };
75486     } catch (std::exception& e) {
75487       {
75488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75489       };
75490     } catch (Dali::DaliException e) {
75491       {
75492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75493       };
75494     } catch (...) {
75495       {
75496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75497       };
75498     }
75499   }
75500
75501 }
75502
75503
75504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75505   unsigned int jresult ;
75506   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75507   unsigned int result;
75508
75509   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75510   {
75511     try {
75512       result = (unsigned int)(arg1)->GetNumberOfItems();
75513     } catch (std::out_of_range& e) {
75514       {
75515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75516       };
75517     } catch (std::exception& e) {
75518       {
75519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75520       };
75521     } catch (Dali::DaliException e) {
75522       {
75523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75524       };
75525     } catch (...) {
75526       {
75527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75528       };
75529     }
75530   }
75531
75532   jresult = result;
75533   return jresult;
75534 }
75535
75536
75537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75538   void * jresult ;
75539   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75540   unsigned int arg2 ;
75541   Dali::Actor result;
75542
75543   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75544   arg2 = (unsigned int)jarg2;
75545   {
75546     try {
75547       result = (arg1)->NewItem(arg2);
75548     } catch (std::out_of_range& e) {
75549       {
75550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75551       };
75552     } catch (std::exception& e) {
75553       {
75554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75555       };
75556     } catch (Dali::DaliException e) {
75557       {
75558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75559       };
75560     } catch (...) {
75561       {
75562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75563       };
75564     }
75565   }
75566
75567   jresult = new Dali::Actor((const Dali::Actor &)result);
75568   return jresult;
75569 }
75570
75571
75572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75573   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75574   unsigned int arg2 ;
75575   Dali::Actor arg3 ;
75576   Dali::Actor *argp3 ;
75577
75578   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75579   arg2 = (unsigned int)jarg2;
75580   argp3 = (Dali::Actor *)jarg3;
75581   if (!argp3) {
75582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75583     return ;
75584   }
75585   arg3 = *argp3;
75586   {
75587     try {
75588       (arg1)->ItemReleased(arg2,arg3);
75589     } catch (std::out_of_range& e) {
75590       {
75591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75592       };
75593     } catch (std::exception& e) {
75594       {
75595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75596       };
75597     } catch (Dali::DaliException e) {
75598       {
75599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75600       };
75601     } catch (...) {
75602       {
75603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75604       };
75605     }
75606   }
75607
75608 }
75609
75610
75611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75612   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75613   unsigned int arg2 ;
75614   Dali::Actor arg3 ;
75615   Dali::Actor *argp3 ;
75616
75617   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75618   arg2 = (unsigned int)jarg2;
75619   argp3 = (Dali::Actor *)jarg3;
75620   if (!argp3) {
75621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75622     return ;
75623   }
75624   arg3 = *argp3;
75625   {
75626     try {
75627       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75628     } catch (std::out_of_range& e) {
75629       {
75630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75631       };
75632     } catch (std::exception& e) {
75633       {
75634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75635       };
75636     } catch (Dali::DaliException e) {
75637       {
75638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75639       };
75640     } catch (...) {
75641       {
75642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75643       };
75644     }
75645   }
75646
75647 }
75648
75649
75650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75651   void * jresult ;
75652   Dali::Toolkit::ItemFactory *result = 0 ;
75653
75654   {
75655     try {
75656       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75657     } catch (std::out_of_range& e) {
75658       {
75659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75660       };
75661     } catch (std::exception& e) {
75662       {
75663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75664       };
75665     } catch (Dali::DaliException e) {
75666       {
75667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75668       };
75669     } catch (...) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75672       };
75673     }
75674   }
75675
75676   jresult = (void *)result;
75677   return jresult;
75678 }
75679
75680
75681 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) {
75682   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75683   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75684   if (director) {
75685     director->swig_connect_director(callback0, callback1, callback2);
75686   }
75687 }
75688
75689
75690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75691   int jresult ;
75692   int result;
75693
75694   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75695   jresult = (int)result;
75696   return jresult;
75697 }
75698
75699
75700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75701   int jresult ;
75702   int result;
75703
75704   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75705   jresult = (int)result;
75706   return jresult;
75707 }
75708
75709
75710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75711   int jresult ;
75712   int result;
75713
75714   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75715   jresult = (int)result;
75716   return jresult;
75717 }
75718
75719
75720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75721   int jresult ;
75722   int result;
75723
75724   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75725   jresult = (int)result;
75726   return jresult;
75727 }
75728
75729
75730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75731   int jresult ;
75732   int result;
75733
75734   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75735   jresult = (int)result;
75736   return jresult;
75737 }
75738
75739
75740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75741   int jresult ;
75742   int result;
75743
75744   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75745   jresult = (int)result;
75746   return jresult;
75747 }
75748
75749
75750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75751   int jresult ;
75752   int result;
75753
75754   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75755   jresult = (int)result;
75756   return jresult;
75757 }
75758
75759
75760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75761   int jresult ;
75762   int result;
75763
75764   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75765   jresult = (int)result;
75766   return jresult;
75767 }
75768
75769
75770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75771   int jresult ;
75772   int result;
75773
75774   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75775   jresult = (int)result;
75776   return jresult;
75777 }
75778
75779
75780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75781   int jresult ;
75782   int result;
75783
75784   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75785   jresult = (int)result;
75786   return jresult;
75787 }
75788
75789
75790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75791   int jresult ;
75792   int result;
75793
75794   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75795   jresult = (int)result;
75796   return jresult;
75797 }
75798
75799
75800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75801   void * jresult ;
75802   Dali::Toolkit::ItemView::Property *result = 0 ;
75803
75804   {
75805     try {
75806       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75807     } catch (std::out_of_range& e) {
75808       {
75809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75810       };
75811     } catch (std::exception& e) {
75812       {
75813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75814       };
75815     } catch (Dali::DaliException e) {
75816       {
75817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75818       };
75819     } catch (...) {
75820       {
75821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75822       };
75823     }
75824   }
75825
75826   jresult = (void *)result;
75827   return jresult;
75828 }
75829
75830
75831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75832   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75833
75834   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75835   {
75836     try {
75837       delete arg1;
75838     } catch (std::out_of_range& e) {
75839       {
75840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75841       };
75842     } catch (std::exception& e) {
75843       {
75844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75845       };
75846     } catch (Dali::DaliException e) {
75847       {
75848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75849       };
75850     } catch (...) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75853       };
75854     }
75855   }
75856
75857 }
75858
75859
75860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75861   void * jresult ;
75862   Dali::Toolkit::ItemView *result = 0 ;
75863
75864   {
75865     try {
75866       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75867     } catch (std::out_of_range& e) {
75868       {
75869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75870       };
75871     } catch (std::exception& e) {
75872       {
75873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75874       };
75875     } catch (Dali::DaliException e) {
75876       {
75877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75878       };
75879     } catch (...) {
75880       {
75881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75882       };
75883     }
75884   }
75885
75886   jresult = (void *)result;
75887   return jresult;
75888 }
75889
75890
75891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75892   void * jresult ;
75893   Dali::Toolkit::ItemView *arg1 = 0 ;
75894   Dali::Toolkit::ItemView *result = 0 ;
75895
75896   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75897   if (!arg1) {
75898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75899     return 0;
75900   }
75901   {
75902     try {
75903       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75904     } catch (std::out_of_range& e) {
75905       {
75906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75907       };
75908     } catch (std::exception& e) {
75909       {
75910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75911       };
75912     } catch (Dali::DaliException e) {
75913       {
75914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75915       };
75916     } catch (...) {
75917       {
75918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75919       };
75920     }
75921   }
75922
75923   jresult = (void *)result;
75924   return jresult;
75925 }
75926
75927
75928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75929   void * jresult ;
75930   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75931   Dali::Toolkit::ItemView *arg2 = 0 ;
75932   Dali::Toolkit::ItemView *result = 0 ;
75933
75934   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75935   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75936   if (!arg2) {
75937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75938     return 0;
75939   }
75940   {
75941     try {
75942       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75943     } catch (std::out_of_range& e) {
75944       {
75945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75946       };
75947     } catch (std::exception& e) {
75948       {
75949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75950       };
75951     } catch (Dali::DaliException e) {
75952       {
75953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75954       };
75955     } catch (...) {
75956       {
75957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75958       };
75959     }
75960   }
75961
75962   jresult = (void *)result;
75963   return jresult;
75964 }
75965
75966
75967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75968   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75969
75970   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75971   {
75972     try {
75973       delete arg1;
75974     } catch (std::out_of_range& e) {
75975       {
75976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75977       };
75978     } catch (std::exception& e) {
75979       {
75980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75981       };
75982     } catch (Dali::DaliException e) {
75983       {
75984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75985       };
75986     } catch (...) {
75987       {
75988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75989       };
75990     }
75991   }
75992
75993 }
75994
75995
75996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75997   void * jresult ;
75998   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75999   Dali::Toolkit::ItemView result;
76000
76001   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76002   if (!arg1) {
76003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76004     return 0;
76005   }
76006   {
76007     try {
76008       result = Dali::Toolkit::ItemView::New(*arg1);
76009     } catch (std::out_of_range& e) {
76010       {
76011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76012       };
76013     } catch (std::exception& e) {
76014       {
76015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76016       };
76017     } catch (Dali::DaliException e) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76020       };
76021     } catch (...) {
76022       {
76023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76024       };
76025     }
76026   }
76027
76028   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76029   return jresult;
76030 }
76031
76032
76033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76034   void * jresult ;
76035   Dali::BaseHandle arg1 ;
76036   Dali::BaseHandle *argp1 ;
76037   Dali::Toolkit::ItemView result;
76038
76039   argp1 = (Dali::BaseHandle *)jarg1;
76040   if (!argp1) {
76041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76042     return 0;
76043   }
76044   arg1 = *argp1;
76045   {
76046     try {
76047       result = Dali::Toolkit::ItemView::DownCast(arg1);
76048     } catch (std::out_of_range& e) {
76049       {
76050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76051       };
76052     } catch (std::exception& e) {
76053       {
76054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76055       };
76056     } catch (Dali::DaliException e) {
76057       {
76058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76059       };
76060     } catch (...) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76063       };
76064     }
76065   }
76066
76067   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76068   return jresult;
76069 }
76070
76071
76072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76073   unsigned int jresult ;
76074   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76075   unsigned int result;
76076
76077   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76078   {
76079     try {
76080       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76081     } catch (std::out_of_range& e) {
76082       {
76083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76084       };
76085     } catch (std::exception& e) {
76086       {
76087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76088       };
76089     } catch (Dali::DaliException e) {
76090       {
76091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76092       };
76093     } catch (...) {
76094       {
76095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76096       };
76097     }
76098   }
76099
76100   jresult = result;
76101   return jresult;
76102 }
76103
76104
76105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76106   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76107   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76108
76109   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76110   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76111   if (!arg2) {
76112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76113     return ;
76114   }
76115   {
76116     try {
76117       (arg1)->AddLayout(*arg2);
76118     } catch (std::out_of_range& e) {
76119       {
76120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76121       };
76122     } catch (std::exception& e) {
76123       {
76124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76125       };
76126     } catch (Dali::DaliException e) {
76127       {
76128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76129       };
76130     } catch (...) {
76131       {
76132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76133       };
76134     }
76135   }
76136
76137 }
76138
76139
76140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76141   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76142   unsigned int arg2 ;
76143
76144   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76145   arg2 = (unsigned int)jarg2;
76146   {
76147     try {
76148       (arg1)->RemoveLayout(arg2);
76149     } catch (std::out_of_range& e) {
76150       {
76151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76152       };
76153     } catch (std::exception& e) {
76154       {
76155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76156       };
76157     } catch (Dali::DaliException e) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76160       };
76161     } catch (...) {
76162       {
76163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76164       };
76165     }
76166   }
76167
76168 }
76169
76170
76171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76172   void * jresult ;
76173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76174   unsigned int arg2 ;
76175   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76176
76177   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76178   arg2 = (unsigned int)jarg2;
76179   {
76180     try {
76181       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76182     } catch (std::out_of_range& e) {
76183       {
76184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76185       };
76186     } catch (std::exception& e) {
76187       {
76188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76189       };
76190     } catch (Dali::DaliException e) {
76191       {
76192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76193       };
76194     } catch (...) {
76195       {
76196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76197       };
76198     }
76199   }
76200
76201   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76202   return jresult;
76203 }
76204
76205
76206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76207   void * jresult ;
76208   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76209   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76210
76211   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76212   {
76213     try {
76214       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76215     } catch (std::out_of_range& e) {
76216       {
76217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76218       };
76219     } catch (std::exception& e) {
76220       {
76221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76222       };
76223     } catch (Dali::DaliException e) {
76224       {
76225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76226       };
76227     } catch (...) {
76228       {
76229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76230       };
76231     }
76232   }
76233
76234   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76235   return jresult;
76236 }
76237
76238
76239 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76240   float jresult ;
76241   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76242   Dali::Toolkit::ItemId arg2 ;
76243   float result;
76244
76245   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76246   arg2 = (Dali::Toolkit::ItemId)jarg2;
76247   {
76248     try {
76249       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76250     } catch (std::out_of_range& e) {
76251       {
76252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76253       };
76254     } catch (std::exception& e) {
76255       {
76256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76257       };
76258     } catch (Dali::DaliException e) {
76259       {
76260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76261       };
76262     } catch (...) {
76263       {
76264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76265       };
76266     }
76267   }
76268
76269   jresult = result;
76270   return jresult;
76271 }
76272
76273
76274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76275   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76276   unsigned int arg2 ;
76277   Dali::Vector3 arg3 ;
76278   float arg4 ;
76279   Dali::Vector3 *argp3 ;
76280
76281   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76282   arg2 = (unsigned int)jarg2;
76283   argp3 = (Dali::Vector3 *)jarg3;
76284   if (!argp3) {
76285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76286     return ;
76287   }
76288   arg3 = *argp3;
76289   arg4 = (float)jarg4;
76290   {
76291     try {
76292       (arg1)->ActivateLayout(arg2,arg3,arg4);
76293     } catch (std::out_of_range& e) {
76294       {
76295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76296       };
76297     } catch (std::exception& e) {
76298       {
76299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76300       };
76301     } catch (Dali::DaliException e) {
76302       {
76303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76304       };
76305     } catch (...) {
76306       {
76307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76308       };
76309     }
76310   }
76311
76312 }
76313
76314
76315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76316   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76317
76318   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76319   {
76320     try {
76321       (arg1)->DeactivateCurrentLayout();
76322     } catch (std::out_of_range& e) {
76323       {
76324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76325       };
76326     } catch (std::exception& e) {
76327       {
76328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76329       };
76330     } catch (Dali::DaliException e) {
76331       {
76332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76333       };
76334     } catch (...) {
76335       {
76336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76337       };
76338     }
76339   }
76340
76341 }
76342
76343
76344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76345   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76346   float arg2 ;
76347
76348   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76349   arg2 = (float)jarg2;
76350   {
76351     try {
76352       (arg1)->SetMinimumSwipeSpeed(arg2);
76353     } catch (std::out_of_range& e) {
76354       {
76355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (std::exception& e) {
76358       {
76359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76360       };
76361     } catch (Dali::DaliException e) {
76362       {
76363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76364       };
76365     } catch (...) {
76366       {
76367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76368       };
76369     }
76370   }
76371
76372 }
76373
76374
76375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76376   float jresult ;
76377   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76378   float result;
76379
76380   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76381   {
76382     try {
76383       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76384     } catch (std::out_of_range& e) {
76385       {
76386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76387       };
76388     } catch (std::exception& e) {
76389       {
76390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76391       };
76392     } catch (Dali::DaliException e) {
76393       {
76394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76395       };
76396     } catch (...) {
76397       {
76398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76399       };
76400     }
76401   }
76402
76403   jresult = result;
76404   return jresult;
76405 }
76406
76407
76408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76409   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76410   float arg2 ;
76411
76412   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76413   arg2 = (float)jarg2;
76414   {
76415     try {
76416       (arg1)->SetMinimumSwipeDistance(arg2);
76417     } catch (std::out_of_range& e) {
76418       {
76419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76420       };
76421     } catch (std::exception& e) {
76422       {
76423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76424       };
76425     } catch (Dali::DaliException e) {
76426       {
76427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76428       };
76429     } catch (...) {
76430       {
76431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76432       };
76433     }
76434   }
76435
76436 }
76437
76438
76439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76440   float jresult ;
76441   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76442   float result;
76443
76444   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76445   {
76446     try {
76447       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76448     } catch (std::out_of_range& e) {
76449       {
76450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76451       };
76452     } catch (std::exception& e) {
76453       {
76454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76455       };
76456     } catch (Dali::DaliException e) {
76457       {
76458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76459       };
76460     } catch (...) {
76461       {
76462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76463       };
76464     }
76465   }
76466
76467   jresult = result;
76468   return jresult;
76469 }
76470
76471
76472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76473   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76474   float arg2 ;
76475
76476   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76477   arg2 = (float)jarg2;
76478   {
76479     try {
76480       (arg1)->SetWheelScrollDistanceStep(arg2);
76481     } catch (std::out_of_range& e) {
76482       {
76483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76484       };
76485     } catch (std::exception& e) {
76486       {
76487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76488       };
76489     } catch (Dali::DaliException e) {
76490       {
76491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76492       };
76493     } catch (...) {
76494       {
76495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76496       };
76497     }
76498   }
76499
76500 }
76501
76502
76503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76504   float jresult ;
76505   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76506   float result;
76507
76508   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76509   {
76510     try {
76511       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76512     } catch (std::out_of_range& e) {
76513       {
76514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76515       };
76516     } catch (std::exception& e) {
76517       {
76518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76519       };
76520     } catch (Dali::DaliException e) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76523       };
76524     } catch (...) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76527       };
76528     }
76529   }
76530
76531   jresult = result;
76532   return jresult;
76533 }
76534
76535
76536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76537   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76538   bool arg2 ;
76539
76540   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76541   arg2 = jarg2 ? true : false;
76542   {
76543     try {
76544       (arg1)->SetAnchoring(arg2);
76545     } catch (std::out_of_range& e) {
76546       {
76547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76548       };
76549     } catch (std::exception& e) {
76550       {
76551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76552       };
76553     } catch (Dali::DaliException e) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76556       };
76557     } catch (...) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76560       };
76561     }
76562   }
76563
76564 }
76565
76566 //// ========================= end of part 3 =============================
76567
76568 //// ========================== start part 4 ===============================
76569
76570
76571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76572   unsigned int jresult ;
76573   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76574   bool result;
76575
76576   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76577   {
76578     try {
76579       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
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_SetAnchoringDuration(void * jarg1, float jarg2) {
76605   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76606   float arg2 ;
76607
76608   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76609   arg2 = (float)jarg2;
76610   {
76611     try {
76612       (arg1)->SetAnchoringDuration(arg2);
76613     } catch (std::out_of_range& e) {
76614       {
76615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76616       };
76617     } catch (std::exception& e) {
76618       {
76619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76620       };
76621     } catch (Dali::DaliException e) {
76622       {
76623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76624       };
76625     } catch (...) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76628       };
76629     }
76630   }
76631
76632 }
76633
76634
76635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76636   float jresult ;
76637   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76638   float result;
76639
76640   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76641   {
76642     try {
76643       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76644     } catch (std::out_of_range& e) {
76645       {
76646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76647       };
76648     } catch (std::exception& e) {
76649       {
76650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76651       };
76652     } catch (Dali::DaliException e) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76655       };
76656     } catch (...) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76659       };
76660     }
76661   }
76662
76663   jresult = result;
76664   return jresult;
76665 }
76666
76667
76668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76669   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76670   Dali::Toolkit::ItemId arg2 ;
76671   float arg3 ;
76672
76673   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76674   arg2 = (Dali::Toolkit::ItemId)jarg2;
76675   arg3 = (float)jarg3;
76676   {
76677     try {
76678       (arg1)->ScrollToItem(arg2,arg3);
76679     } catch (std::out_of_range& e) {
76680       {
76681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76682       };
76683     } catch (std::exception& e) {
76684       {
76685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76686       };
76687     } catch (Dali::DaliException e) {
76688       {
76689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76690       };
76691     } catch (...) {
76692       {
76693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76694       };
76695     }
76696   }
76697
76698 }
76699
76700
76701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76702   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76703   float arg2 ;
76704
76705   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76706   arg2 = (float)jarg2;
76707   {
76708     try {
76709       (arg1)->SetRefreshInterval(arg2);
76710     } catch (std::out_of_range& e) {
76711       {
76712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76713       };
76714     } catch (std::exception& e) {
76715       {
76716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76717       };
76718     } catch (Dali::DaliException e) {
76719       {
76720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76721       };
76722     } catch (...) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76725       };
76726     }
76727   }
76728
76729 }
76730
76731
76732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76733   float jresult ;
76734   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76735   float result;
76736
76737   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76738   {
76739     try {
76740       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76741     } catch (std::out_of_range& e) {
76742       {
76743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76744       };
76745     } catch (std::exception& e) {
76746       {
76747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76748       };
76749     } catch (Dali::DaliException e) {
76750       {
76751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76752       };
76753     } catch (...) {
76754       {
76755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76756       };
76757     }
76758   }
76759
76760   jresult = result;
76761   return jresult;
76762 }
76763
76764
76765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76766   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76767
76768   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76769   {
76770     try {
76771       (arg1)->Refresh();
76772     } catch (std::out_of_range& e) {
76773       {
76774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76775       };
76776     } catch (std::exception& e) {
76777       {
76778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76779       };
76780     } catch (Dali::DaliException e) {
76781       {
76782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76783       };
76784     } catch (...) {
76785       {
76786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76787       };
76788     }
76789   }
76790
76791 }
76792
76793
76794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76795   void * jresult ;
76796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76797   Dali::Toolkit::ItemId arg2 ;
76798   Dali::Actor result;
76799
76800   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76801   arg2 = (Dali::Toolkit::ItemId)jarg2;
76802   {
76803     try {
76804       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76805     } catch (std::out_of_range& e) {
76806       {
76807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76808       };
76809     } catch (std::exception& e) {
76810       {
76811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76812       };
76813     } catch (Dali::DaliException e) {
76814       {
76815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76816       };
76817     } catch (...) {
76818       {
76819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76820       };
76821     }
76822   }
76823
76824   jresult = new Dali::Actor((const Dali::Actor &)result);
76825   return jresult;
76826 }
76827
76828
76829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76830   unsigned int jresult ;
76831   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76832   Dali::Actor arg2 ;
76833   Dali::Actor *argp2 ;
76834   Dali::Toolkit::ItemId result;
76835
76836   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76837   argp2 = (Dali::Actor *)jarg2;
76838   if (!argp2) {
76839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76840     return 0;
76841   }
76842   arg2 = *argp2;
76843   {
76844     try {
76845       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76846     } catch (std::out_of_range& e) {
76847       {
76848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76849       };
76850     } catch (std::exception& e) {
76851       {
76852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76853       };
76854     } catch (Dali::DaliException e) {
76855       {
76856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76857       };
76858     } catch (...) {
76859       {
76860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76861       };
76862     }
76863   }
76864
76865   jresult = result;
76866   return jresult;
76867 }
76868
76869
76870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76871   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76872   Dali::Toolkit::Item arg2 ;
76873   float arg3 ;
76874   Dali::Toolkit::Item *argp2 ;
76875
76876   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76877   argp2 = (Dali::Toolkit::Item *)jarg2;
76878   if (!argp2) {
76879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76880     return ;
76881   }
76882   arg2 = *argp2;
76883   arg3 = (float)jarg3;
76884   {
76885     try {
76886       (arg1)->InsertItem(arg2,arg3);
76887     } catch (std::out_of_range& e) {
76888       {
76889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76890       };
76891     } catch (std::exception& e) {
76892       {
76893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76894       };
76895     } catch (Dali::DaliException e) {
76896       {
76897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76898       };
76899     } catch (...) {
76900       {
76901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76902       };
76903     }
76904   }
76905
76906 }
76907
76908
76909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76910   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76911   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76912   float arg3 ;
76913
76914   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76915   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76916   if (!arg2) {
76917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76918     return ;
76919   }
76920   arg3 = (float)jarg3;
76921   {
76922     try {
76923       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76924     } catch (std::out_of_range& e) {
76925       {
76926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76927       };
76928     } catch (std::exception& e) {
76929       {
76930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76931       };
76932     } catch (Dali::DaliException e) {
76933       {
76934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76935       };
76936     } catch (...) {
76937       {
76938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76939       };
76940     }
76941   }
76942
76943 }
76944
76945
76946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76947   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76948   Dali::Toolkit::ItemId arg2 ;
76949   float arg3 ;
76950
76951   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76952   arg2 = (Dali::Toolkit::ItemId)jarg2;
76953   arg3 = (float)jarg3;
76954   {
76955     try {
76956       (arg1)->RemoveItem(arg2,arg3);
76957     } catch (std::out_of_range& e) {
76958       {
76959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76960       };
76961     } catch (std::exception& e) {
76962       {
76963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76964       };
76965     } catch (Dali::DaliException e) {
76966       {
76967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76968       };
76969     } catch (...) {
76970       {
76971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76972       };
76973     }
76974   }
76975
76976 }
76977
76978
76979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76980   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76981   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76982   float arg3 ;
76983
76984   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76985   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76986   if (!arg2) {
76987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76988     return ;
76989   }
76990   arg3 = (float)jarg3;
76991   {
76992     try {
76993       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76994     } catch (std::out_of_range& e) {
76995       {
76996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76997       };
76998     } catch (std::exception& e) {
76999       {
77000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77001       };
77002     } catch (Dali::DaliException e) {
77003       {
77004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77005       };
77006     } catch (...) {
77007       {
77008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77009       };
77010     }
77011   }
77012
77013 }
77014
77015
77016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77017   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77018   Dali::Toolkit::Item arg2 ;
77019   float arg3 ;
77020   Dali::Toolkit::Item *argp2 ;
77021
77022   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77023   argp2 = (Dali::Toolkit::Item *)jarg2;
77024   if (!argp2) {
77025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77026     return ;
77027   }
77028   arg2 = *argp2;
77029   arg3 = (float)jarg3;
77030   {
77031     try {
77032       (arg1)->ReplaceItem(arg2,arg3);
77033     } catch (std::out_of_range& e) {
77034       {
77035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77036       };
77037     } catch (std::exception& e) {
77038       {
77039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77040       };
77041     } catch (Dali::DaliException e) {
77042       {
77043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77044       };
77045     } catch (...) {
77046       {
77047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77048       };
77049     }
77050   }
77051
77052 }
77053
77054
77055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77056   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77057   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77058   float arg3 ;
77059
77060   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77061   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77062   if (!arg2) {
77063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77064     return ;
77065   }
77066   arg3 = (float)jarg3;
77067   {
77068     try {
77069       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77070     } catch (std::out_of_range& e) {
77071       {
77072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77073       };
77074     } catch (std::exception& e) {
77075       {
77076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77077       };
77078     } catch (Dali::DaliException e) {
77079       {
77080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77081       };
77082     } catch (...) {
77083       {
77084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77085       };
77086     }
77087   }
77088
77089 }
77090
77091
77092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77093   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77094   Dali::Vector3 *arg2 = 0 ;
77095
77096   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77097   arg2 = (Dali::Vector3 *)jarg2;
77098   if (!arg2) {
77099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77100     return ;
77101   }
77102   {
77103     try {
77104       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77105     } catch (std::out_of_range& e) {
77106       {
77107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77108       };
77109     } catch (std::exception& e) {
77110       {
77111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77112       };
77113     } catch (Dali::DaliException e) {
77114       {
77115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77116       };
77117     } catch (...) {
77118       {
77119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77120       };
77121     }
77122   }
77123
77124 }
77125
77126
77127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77128   void * jresult ;
77129   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77130   Dali::Vector3 result;
77131
77132   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77133   {
77134     try {
77135       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77136     } catch (std::out_of_range& e) {
77137       {
77138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77139       };
77140     } catch (std::exception& e) {
77141       {
77142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77143       };
77144     } catch (Dali::DaliException e) {
77145       {
77146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77147       };
77148     } catch (...) {
77149       {
77150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77151       };
77152     }
77153   }
77154
77155   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77156   return jresult;
77157 }
77158
77159
77160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77161   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77162   Dali::Vector3 *arg2 = 0 ;
77163
77164   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77165   arg2 = (Dali::Vector3 *)jarg2;
77166   if (!arg2) {
77167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77168     return ;
77169   }
77170   {
77171     try {
77172       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77173     } catch (std::out_of_range& e) {
77174       {
77175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77176       };
77177     } catch (std::exception& e) {
77178       {
77179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77180       };
77181     } catch (Dali::DaliException e) {
77182       {
77183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77184       };
77185     } catch (...) {
77186       {
77187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77188       };
77189     }
77190   }
77191
77192 }
77193
77194
77195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77196   void * jresult ;
77197   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77198   Dali::Vector3 result;
77199
77200   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77201   {
77202     try {
77203       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77204     } catch (std::out_of_range& e) {
77205       {
77206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77207       };
77208     } catch (std::exception& e) {
77209       {
77210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77211       };
77212     } catch (Dali::DaliException e) {
77213       {
77214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77215       };
77216     } catch (...) {
77217       {
77218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77219       };
77220     }
77221   }
77222
77223   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77224   return jresult;
77225 }
77226
77227
77228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77229   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77230   Dali::Toolkit::ItemRange *arg2 = 0 ;
77231
77232   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77233   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77234   if (!arg2) {
77235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77236     return ;
77237   }
77238   {
77239     try {
77240       (arg1)->GetItemsRange(*arg2);
77241     } catch (std::out_of_range& e) {
77242       {
77243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77244       };
77245     } catch (std::exception& e) {
77246       {
77247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77248       };
77249     } catch (Dali::DaliException e) {
77250       {
77251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77252       };
77253     } catch (...) {
77254       {
77255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77256       };
77257     }
77258   }
77259
77260 }
77261
77262
77263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77264   void * jresult ;
77265   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77266   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77267
77268   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77269   {
77270     try {
77271       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77272     } catch (std::out_of_range& e) {
77273       {
77274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77275       };
77276     } catch (std::exception& e) {
77277       {
77278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77279       };
77280     } catch (Dali::DaliException e) {
77281       {
77282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77283       };
77284     } catch (...) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77287       };
77288     }
77289   }
77290
77291   jresult = (void *)result;
77292   return jresult;
77293 }
77294
77295
77296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77297   Dali::Vector3 *arg1 = 0 ;
77298   PropertyInputContainer *arg2 = 0 ;
77299
77300   arg1 = (Dali::Vector3 *)jarg1;
77301   if (!arg1) {
77302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77303     return ;
77304   }
77305   arg2 = (PropertyInputContainer *)jarg2;
77306   if (!arg2) {
77307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77308     return ;
77309   }
77310   {
77311     try {
77312       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77313     } catch (std::out_of_range& e) {
77314       {
77315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77316       };
77317     } catch (std::exception& e) {
77318       {
77319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77320       };
77321     } catch (Dali::DaliException e) {
77322       {
77323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77324       };
77325     } catch (...) {
77326       {
77327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77328       };
77329     }
77330   }
77331
77332 }
77333
77334
77335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77336   Dali::Vector3 *arg1 = 0 ;
77337   PropertyInputContainer *arg2 = 0 ;
77338
77339   arg1 = (Dali::Vector3 *)jarg1;
77340   if (!arg1) {
77341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77342     return ;
77343   }
77344   arg2 = (PropertyInputContainer *)jarg2;
77345   if (!arg2) {
77346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77347     return ;
77348   }
77349   {
77350     try {
77351       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77352     } catch (std::out_of_range& e) {
77353       {
77354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77355       };
77356     } catch (std::exception& e) {
77357       {
77358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77359       };
77360     } catch (Dali::DaliException e) {
77361       {
77362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77363       };
77364     } catch (...) {
77365       {
77366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77367       };
77368     }
77369   }
77370
77371 }
77372
77373
77374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77375   void * jresult ;
77376   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77377
77378   {
77379     try {
77380       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77381     } catch (std::out_of_range& e) {
77382       {
77383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77384       };
77385     } catch (std::exception& e) {
77386       {
77387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77388       };
77389     } catch (Dali::DaliException e) {
77390       {
77391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77392       };
77393     } catch (...) {
77394       {
77395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77396       };
77397     }
77398   }
77399
77400   jresult = (void *)result;
77401   return jresult;
77402 }
77403
77404
77405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77406   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77407
77408   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77409   {
77410     try {
77411       delete arg1;
77412     } catch (std::out_of_range& e) {
77413       {
77414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77415       };
77416     } catch (std::exception& e) {
77417       {
77418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77419       };
77420     } catch (Dali::DaliException e) {
77421       {
77422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77423       };
77424     } catch (...) {
77425       {
77426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77427       };
77428     }
77429   }
77430
77431 }
77432
77433
77434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77435   void * jresult ;
77436   Dali::Path arg1 ;
77437   Dali::Vector3 *arg2 = 0 ;
77438   Dali::Property::Index arg3 ;
77439   Dali::Vector3 *arg4 = 0 ;
77440   unsigned int arg5 ;
77441   Dali::Path *argp1 ;
77442   Dali::Toolkit::ScrollViewPagePathEffect result;
77443
77444   argp1 = (Dali::Path *)jarg1;
77445   if (!argp1) {
77446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77447     return 0;
77448   }
77449   arg1 = *argp1;
77450   arg2 = (Dali::Vector3 *)jarg2;
77451   if (!arg2) {
77452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77453     return 0;
77454   }
77455   arg3 = (Dali::Property::Index)jarg3;
77456   arg4 = (Dali::Vector3 *)jarg4;
77457   if (!arg4) {
77458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77459     return 0;
77460   }
77461   arg5 = (unsigned int)jarg5;
77462   {
77463     try {
77464       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77465     } catch (std::out_of_range& e) {
77466       {
77467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77468       };
77469     } catch (std::exception& e) {
77470       {
77471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77472       };
77473     } catch (Dali::DaliException e) {
77474       {
77475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77476       };
77477     } catch (...) {
77478       {
77479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77480       };
77481     }
77482   }
77483
77484   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77485   return jresult;
77486 }
77487
77488
77489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77490   void * jresult ;
77491   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77492
77493   {
77494     try {
77495       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77496     } catch (std::out_of_range& e) {
77497       {
77498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77499       };
77500     } catch (std::exception& e) {
77501       {
77502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77503       };
77504     } catch (Dali::DaliException e) {
77505       {
77506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77507       };
77508     } catch (...) {
77509       {
77510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77511       };
77512     }
77513   }
77514
77515   jresult = (void *)result;
77516   return jresult;
77517 }
77518
77519
77520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77521   void * jresult ;
77522   Dali::BaseHandle arg1 ;
77523   Dali::BaseHandle *argp1 ;
77524   Dali::Toolkit::ScrollViewPagePathEffect result;
77525
77526   argp1 = (Dali::BaseHandle *)jarg1;
77527   if (!argp1) {
77528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77529     return 0;
77530   }
77531   arg1 = *argp1;
77532   {
77533     try {
77534       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77535     } catch (std::out_of_range& e) {
77536       {
77537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77538       };
77539     } catch (std::exception& e) {
77540       {
77541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77542       };
77543     } catch (Dali::DaliException e) {
77544       {
77545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77546       };
77547     } catch (...) {
77548       {
77549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77550       };
77551     }
77552   }
77553
77554   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77555   return jresult;
77556 }
77557
77558
77559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77560   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77561   Dali::Actor arg2 ;
77562   unsigned int arg3 ;
77563   Dali::Actor *argp2 ;
77564
77565   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77566   argp2 = (Dali::Actor *)jarg2;
77567   if (!argp2) {
77568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77569     return ;
77570   }
77571   arg2 = *argp2;
77572   arg3 = (unsigned int)jarg3;
77573   {
77574     try {
77575       (arg1)->ApplyToPage(arg2,arg3);
77576     } catch (std::out_of_range& e) {
77577       {
77578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77579       };
77580     } catch (std::exception& e) {
77581       {
77582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77583       };
77584     } catch (Dali::DaliException e) {
77585       {
77586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77587       };
77588     } catch (...) {
77589       {
77590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77591       };
77592     }
77593   }
77594
77595 }
77596
77597
77598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77599   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77600
77601   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77602   {
77603     try {
77604       delete arg1;
77605     } catch (std::out_of_range& e) {
77606       {
77607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77608       };
77609     } catch (std::exception& e) {
77610       {
77611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77612       };
77613     } catch (Dali::DaliException e) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77616       };
77617     } catch (...) {
77618       {
77619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77620       };
77621     }
77622   }
77623
77624 }
77625
77626
77627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77628   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77629   Dali::Toolkit::ClampState arg2 ;
77630
77631   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77632   arg2 = (Dali::Toolkit::ClampState)jarg2;
77633   if (arg1) (arg1)->x = arg2;
77634 }
77635
77636
77637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77638   int jresult ;
77639   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77640   Dali::Toolkit::ClampState result;
77641
77642   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77643   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77644   jresult = (int)result;
77645   return jresult;
77646 }
77647
77648
77649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77650   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77651   Dali::Toolkit::ClampState arg2 ;
77652
77653   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77654   arg2 = (Dali::Toolkit::ClampState)jarg2;
77655   if (arg1) (arg1)->y = arg2;
77656 }
77657
77658
77659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77660   int jresult ;
77661   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77662   Dali::Toolkit::ClampState result;
77663
77664   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77665   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77666   jresult = (int)result;
77667   return jresult;
77668 }
77669
77670
77671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77672   void * jresult ;
77673   Dali::Toolkit::ClampState2D *result = 0 ;
77674
77675   {
77676     try {
77677       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77678     } catch (std::out_of_range& e) {
77679       {
77680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77681       };
77682     } catch (std::exception& e) {
77683       {
77684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77685       };
77686     } catch (Dali::DaliException e) {
77687       {
77688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77689       };
77690     } catch (...) {
77691       {
77692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77693       };
77694     }
77695   }
77696
77697   jresult = (void *)result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77703   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77704
77705   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77706   {
77707     try {
77708       delete arg1;
77709     } catch (std::out_of_range& e) {
77710       {
77711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77712       };
77713     } catch (std::exception& e) {
77714       {
77715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77716       };
77717     } catch (Dali::DaliException e) {
77718       {
77719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77720       };
77721     } catch (...) {
77722       {
77723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77724       };
77725     }
77726   }
77727
77728 }
77729
77730
77731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77732   void * jresult ;
77733   float arg1 ;
77734   float arg2 ;
77735   bool arg3 ;
77736   Dali::Toolkit::RulerDomain *result = 0 ;
77737
77738   arg1 = (float)jarg1;
77739   arg2 = (float)jarg2;
77740   arg3 = jarg3 ? true : false;
77741   {
77742     try {
77743       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (Dali::DaliException e) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77759       };
77760     }
77761   }
77762
77763   jresult = (void *)result;
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77769   void * jresult ;
77770   float arg1 ;
77771   float arg2 ;
77772   Dali::Toolkit::RulerDomain *result = 0 ;
77773
77774   arg1 = (float)jarg1;
77775   arg2 = (float)jarg2;
77776   {
77777     try {
77778       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77779     } catch (std::out_of_range& e) {
77780       {
77781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77782       };
77783     } catch (std::exception& e) {
77784       {
77785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77786       };
77787     } catch (Dali::DaliException e) {
77788       {
77789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77790       };
77791     } catch (...) {
77792       {
77793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77794       };
77795     }
77796   }
77797
77798   jresult = (void *)result;
77799   return jresult;
77800 }
77801
77802
77803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77804   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77805   float arg2 ;
77806
77807   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77808   arg2 = (float)jarg2;
77809   if (arg1) (arg1)->min = arg2;
77810 }
77811
77812
77813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77814   float jresult ;
77815   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77816   float result;
77817
77818   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77819   result = (float) ((arg1)->min);
77820   jresult = result;
77821   return jresult;
77822 }
77823
77824
77825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77826   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77827   float arg2 ;
77828
77829   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77830   arg2 = (float)jarg2;
77831   if (arg1) (arg1)->max = arg2;
77832 }
77833
77834
77835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77836   float jresult ;
77837   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77838   float result;
77839
77840   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77841   result = (float) ((arg1)->max);
77842   jresult = result;
77843   return jresult;
77844 }
77845
77846
77847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77848   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77849   bool arg2 ;
77850
77851   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77852   arg2 = jarg2 ? true : false;
77853   if (arg1) (arg1)->enabled = arg2;
77854 }
77855
77856
77857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77858   unsigned int jresult ;
77859   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77860   bool result;
77861
77862   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77863   result = (bool) ((arg1)->enabled);
77864   jresult = result;
77865   return jresult;
77866 }
77867
77868
77869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77870   float jresult ;
77871   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77872   float arg2 ;
77873   float arg3 ;
77874   float arg4 ;
77875   float result;
77876
77877   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77878   arg2 = (float)jarg2;
77879   arg3 = (float)jarg3;
77880   arg4 = (float)jarg4;
77881   {
77882     try {
77883       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77884     } catch (std::out_of_range& e) {
77885       {
77886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77887       };
77888     } catch (std::exception& e) {
77889       {
77890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77891       };
77892     } catch (Dali::DaliException e) {
77893       {
77894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77895       };
77896     } catch (...) {
77897       {
77898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77899       };
77900     }
77901   }
77902
77903   jresult = result;
77904   return jresult;
77905 }
77906
77907
77908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77909   float jresult ;
77910   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77911   float arg2 ;
77912   float arg3 ;
77913   float result;
77914
77915   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77916   arg2 = (float)jarg2;
77917   arg3 = (float)jarg3;
77918   {
77919     try {
77920       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77921     } catch (std::out_of_range& e) {
77922       {
77923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77924       };
77925     } catch (std::exception& e) {
77926       {
77927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77928       };
77929     } catch (Dali::DaliException e) {
77930       {
77931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77932       };
77933     } catch (...) {
77934       {
77935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77936       };
77937     }
77938   }
77939
77940   jresult = result;
77941   return jresult;
77942 }
77943
77944
77945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77946   float jresult ;
77947   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77948   float arg2 ;
77949   float result;
77950
77951   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77952   arg2 = (float)jarg2;
77953   {
77954     try {
77955       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77956     } catch (std::out_of_range& e) {
77957       {
77958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77959       };
77960     } catch (std::exception& e) {
77961       {
77962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77963       };
77964     } catch (Dali::DaliException e) {
77965       {
77966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77967       };
77968     } catch (...) {
77969       {
77970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77971       };
77972     }
77973   }
77974
77975   jresult = result;
77976   return jresult;
77977 }
77978
77979
77980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77981   float jresult ;
77982   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77983   float arg2 ;
77984   float arg3 ;
77985   float arg4 ;
77986   Dali::Toolkit::ClampState *arg5 = 0 ;
77987   float result;
77988
77989   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77990   arg2 = (float)jarg2;
77991   arg3 = (float)jarg3;
77992   arg4 = (float)jarg4;
77993   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77994   if (!arg5) {
77995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77996     return 0;
77997   }
77998   {
77999     try {
78000       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78001     } catch (std::out_of_range& e) {
78002       {
78003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (std::exception& e) {
78006       {
78007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78008       };
78009     } catch (Dali::DaliException e) {
78010       {
78011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78012       };
78013     } catch (...) {
78014       {
78015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78016       };
78017     }
78018   }
78019
78020   jresult = result;
78021   return jresult;
78022 }
78023
78024
78025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78026   float jresult ;
78027   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78028   float result;
78029
78030   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78031   {
78032     try {
78033       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
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 = result;
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78059   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78060
78061   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78062   {
78063     try {
78064       delete arg1;
78065     } catch (std::out_of_range& e) {
78066       {
78067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78068       };
78069     } catch (std::exception& e) {
78070       {
78071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78072       };
78073     } catch (Dali::DaliException e) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78076       };
78077     } catch (...) {
78078       {
78079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78080       };
78081     }
78082   }
78083
78084 }
78085
78086
78087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78088   float jresult ;
78089   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78090   float arg2 ;
78091   float arg3 ;
78092   float result;
78093
78094   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78095   arg2 = (float)jarg2;
78096   arg3 = (float)jarg3;
78097   {
78098     try {
78099       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78100     } catch (std::out_of_range& e) {
78101       {
78102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78103       };
78104     } catch (std::exception& e) {
78105       {
78106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78107       };
78108     } catch (Dali::DaliException e) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78111       };
78112     } catch (...) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78115       };
78116     }
78117   }
78118
78119   jresult = result;
78120   return jresult;
78121 }
78122
78123
78124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78125   float jresult ;
78126   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78127   float arg2 ;
78128   float result;
78129
78130   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78131   arg2 = (float)jarg2;
78132   {
78133     try {
78134       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78135     } catch (std::out_of_range& e) {
78136       {
78137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78138       };
78139     } catch (std::exception& e) {
78140       {
78141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78142       };
78143     } catch (Dali::DaliException e) {
78144       {
78145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78146       };
78147     } catch (...) {
78148       {
78149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78150       };
78151     }
78152   }
78153
78154   jresult = result;
78155   return jresult;
78156 }
78157
78158
78159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78160   float jresult ;
78161   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78162   unsigned int arg2 ;
78163   unsigned int *arg3 = 0 ;
78164   bool arg4 ;
78165   float result;
78166
78167   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78168   arg2 = (unsigned int)jarg2;
78169   arg3 = (unsigned int *)jarg3;
78170   arg4 = jarg4 ? true : false;
78171   {
78172     try {
78173       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78174     } catch (std::out_of_range& e) {
78175       {
78176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78177       };
78178     } catch (std::exception& e) {
78179       {
78180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78181       };
78182     } catch (Dali::DaliException e) {
78183       {
78184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78185       };
78186     } catch (...) {
78187       {
78188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78189       };
78190     }
78191   }
78192
78193   jresult = result;
78194   return jresult;
78195 }
78196
78197
78198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78199   unsigned int jresult ;
78200   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78201   float arg2 ;
78202   bool arg3 ;
78203   unsigned int result;
78204
78205   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78206   arg2 = (float)jarg2;
78207   arg3 = jarg3 ? true : false;
78208   {
78209     try {
78210       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78211     } catch (std::out_of_range& e) {
78212       {
78213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78214       };
78215     } catch (std::exception& e) {
78216       {
78217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78218       };
78219     } catch (Dali::DaliException e) {
78220       {
78221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78222       };
78223     } catch (...) {
78224       {
78225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78226       };
78227     }
78228   }
78229
78230   jresult = result;
78231   return jresult;
78232 }
78233
78234
78235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78236   unsigned int jresult ;
78237   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78238   unsigned int result;
78239
78240   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78241   {
78242     try {
78243       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78244     } catch (std::out_of_range& e) {
78245       {
78246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78247       };
78248     } catch (std::exception& e) {
78249       {
78250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78251       };
78252     } catch (Dali::DaliException e) {
78253       {
78254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78255       };
78256     } catch (...) {
78257       {
78258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78259       };
78260     }
78261   }
78262
78263   jresult = result;
78264   return jresult;
78265 }
78266
78267
78268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78269   int jresult ;
78270   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78271   Dali::Toolkit::Ruler::RulerType result;
78272
78273   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78274   {
78275     try {
78276       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78277     } catch (std::out_of_range& e) {
78278       {
78279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78280       };
78281     } catch (std::exception& e) {
78282       {
78283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78284       };
78285     } catch (Dali::DaliException e) {
78286       {
78287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78288       };
78289     } catch (...) {
78290       {
78291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78292       };
78293     }
78294   }
78295
78296   jresult = (int)result;
78297   return jresult;
78298 }
78299
78300
78301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78302   unsigned int jresult ;
78303   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78304   bool result;
78305
78306   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78307   {
78308     try {
78309       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78310     } catch (std::out_of_range& e) {
78311       {
78312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78313       };
78314     } catch (std::exception& e) {
78315       {
78316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78317       };
78318     } catch (Dali::DaliException e) {
78319       {
78320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78321       };
78322     } catch (...) {
78323       {
78324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78325       };
78326     }
78327   }
78328
78329   jresult = result;
78330   return jresult;
78331 }
78332
78333
78334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78335   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78336
78337   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78338   {
78339     try {
78340       (arg1)->Enable();
78341     } catch (std::out_of_range& e) {
78342       {
78343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78344       };
78345     } catch (std::exception& e) {
78346       {
78347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78348       };
78349     } catch (Dali::DaliException e) {
78350       {
78351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78352       };
78353     } catch (...) {
78354       {
78355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78356       };
78357     }
78358   }
78359
78360 }
78361
78362
78363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78365
78366   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78367   {
78368     try {
78369       (arg1)->Disable();
78370     } catch (std::out_of_range& e) {
78371       {
78372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78373       };
78374     } catch (std::exception& e) {
78375       {
78376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78377       };
78378     } catch (Dali::DaliException e) {
78379       {
78380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78381       };
78382     } catch (...) {
78383       {
78384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78385       };
78386     }
78387   }
78388
78389 }
78390
78391
78392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78393   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78394   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78395   Dali::Toolkit::RulerDomain *argp2 ;
78396
78397   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78398   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78399   if (!argp2) {
78400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78401     return ;
78402   }
78403   arg2 = *argp2;
78404   {
78405     try {
78406       (arg1)->SetDomain(arg2);
78407     } catch (std::out_of_range& e) {
78408       {
78409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78410       };
78411     } catch (std::exception& e) {
78412       {
78413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78414       };
78415     } catch (Dali::DaliException e) {
78416       {
78417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78418       };
78419     } catch (...) {
78420       {
78421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78422       };
78423     }
78424   }
78425
78426 }
78427
78428
78429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78430   void * jresult ;
78431   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78432   Dali::Toolkit::RulerDomain *result = 0 ;
78433
78434   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78435   {
78436     try {
78437       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78438     } catch (std::out_of_range& e) {
78439       {
78440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78441       };
78442     } catch (std::exception& e) {
78443       {
78444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78445       };
78446     } catch (Dali::DaliException e) {
78447       {
78448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78449       };
78450     } catch (...) {
78451       {
78452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78453       };
78454     }
78455   }
78456
78457   jresult = (void *)result;
78458   return jresult;
78459 }
78460
78461
78462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78463   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78464
78465   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78466   {
78467     try {
78468       (arg1)->DisableDomain();
78469     } catch (std::out_of_range& e) {
78470       {
78471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78472       };
78473     } catch (std::exception& e) {
78474       {
78475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78476       };
78477     } catch (Dali::DaliException e) {
78478       {
78479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78480       };
78481     } catch (...) {
78482       {
78483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78484       };
78485     }
78486   }
78487
78488 }
78489
78490
78491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78492   float jresult ;
78493   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78494   float arg2 ;
78495   float arg3 ;
78496   float arg4 ;
78497   float result;
78498
78499   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78500   arg2 = (float)jarg2;
78501   arg3 = (float)jarg3;
78502   arg4 = (float)jarg4;
78503   {
78504     try {
78505       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78506     } catch (std::out_of_range& e) {
78507       {
78508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78509       };
78510     } catch (std::exception& e) {
78511       {
78512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78513       };
78514     } catch (Dali::DaliException e) {
78515       {
78516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78517       };
78518     } catch (...) {
78519       {
78520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78521       };
78522     }
78523   }
78524
78525   jresult = result;
78526   return jresult;
78527 }
78528
78529
78530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78531   float jresult ;
78532   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78533   float arg2 ;
78534   float arg3 ;
78535   float result;
78536
78537   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78538   arg2 = (float)jarg2;
78539   arg3 = (float)jarg3;
78540   {
78541     try {
78542       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78543     } catch (std::out_of_range& e) {
78544       {
78545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78546       };
78547     } catch (std::exception& e) {
78548       {
78549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78550       };
78551     } catch (Dali::DaliException e) {
78552       {
78553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78554       };
78555     } catch (...) {
78556       {
78557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78558       };
78559     }
78560   }
78561
78562   jresult = result;
78563   return jresult;
78564 }
78565
78566
78567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78568   float jresult ;
78569   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78570   float arg2 ;
78571   float result;
78572
78573   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78574   arg2 = (float)jarg2;
78575   {
78576     try {
78577       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78578     } catch (std::out_of_range& e) {
78579       {
78580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78581       };
78582     } catch (std::exception& e) {
78583       {
78584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78585       };
78586     } catch (Dali::DaliException e) {
78587       {
78588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78589       };
78590     } catch (...) {
78591       {
78592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78593       };
78594     }
78595   }
78596
78597   jresult = result;
78598   return jresult;
78599 }
78600
78601
78602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78603   float jresult ;
78604   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78605   float arg2 ;
78606   float arg3 ;
78607   float arg4 ;
78608   Dali::Toolkit::ClampState *arg5 = 0 ;
78609   float result;
78610
78611   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78612   arg2 = (float)jarg2;
78613   arg3 = (float)jarg3;
78614   arg4 = (float)jarg4;
78615   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78616   if (!arg5) {
78617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78618     return 0;
78619   }
78620   {
78621     try {
78622       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78623     } catch (std::out_of_range& e) {
78624       {
78625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78626       };
78627     } catch (std::exception& e) {
78628       {
78629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78630       };
78631     } catch (Dali::DaliException e) {
78632       {
78633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78634       };
78635     } catch (...) {
78636       {
78637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78638       };
78639     }
78640   }
78641
78642   jresult = result;
78643   return jresult;
78644 }
78645
78646
78647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78648   float jresult ;
78649   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78650   float arg2 ;
78651   float arg3 ;
78652   float arg4 ;
78653   float arg5 ;
78654   float result;
78655
78656   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78657   arg2 = (float)jarg2;
78658   arg3 = (float)jarg3;
78659   arg4 = (float)jarg4;
78660   arg5 = (float)jarg5;
78661   {
78662     try {
78663       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78664     } catch (std::out_of_range& e) {
78665       {
78666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78667       };
78668     } catch (std::exception& e) {
78669       {
78670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78671       };
78672     } catch (Dali::DaliException e) {
78673       {
78674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78675       };
78676     } catch (...) {
78677       {
78678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78679       };
78680     }
78681   }
78682
78683   jresult = result;
78684   return jresult;
78685 }
78686
78687
78688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78689   float jresult ;
78690   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78691   float arg2 ;
78692   float arg3 ;
78693   float arg4 ;
78694   float result;
78695
78696   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78697   arg2 = (float)jarg2;
78698   arg3 = (float)jarg3;
78699   arg4 = (float)jarg4;
78700   {
78701     try {
78702       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78703     } catch (std::out_of_range& e) {
78704       {
78705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78706       };
78707     } catch (std::exception& e) {
78708       {
78709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78710       };
78711     } catch (Dali::DaliException e) {
78712       {
78713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78714       };
78715     } catch (...) {
78716       {
78717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78718       };
78719     }
78720   }
78721
78722   jresult = result;
78723   return jresult;
78724 }
78725
78726
78727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78728   float jresult ;
78729   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78730   float arg2 ;
78731   float arg3 ;
78732   float result;
78733
78734   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78735   arg2 = (float)jarg2;
78736   arg3 = (float)jarg3;
78737   {
78738     try {
78739       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78740     } catch (std::out_of_range& e) {
78741       {
78742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78743       };
78744     } catch (std::exception& e) {
78745       {
78746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78747       };
78748     } catch (Dali::DaliException e) {
78749       {
78750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78751       };
78752     } catch (...) {
78753       {
78754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78755       };
78756     }
78757   }
78758
78759   jresult = result;
78760   return jresult;
78761 }
78762
78763
78764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78765   float jresult ;
78766   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78767   float arg2 ;
78768   float result;
78769
78770   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78771   arg2 = (float)jarg2;
78772   {
78773     try {
78774       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78775     } catch (std::out_of_range& e) {
78776       {
78777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78778       };
78779     } catch (std::exception& e) {
78780       {
78781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78782       };
78783     } catch (Dali::DaliException e) {
78784       {
78785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78786       };
78787     } catch (...) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78790       };
78791     }
78792   }
78793
78794   jresult = result;
78795   return jresult;
78796 }
78797
78798
78799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78800   float jresult ;
78801   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78802   float arg2 ;
78803   float arg3 ;
78804   float arg4 ;
78805   float arg5 ;
78806   Dali::Toolkit::ClampState *arg6 = 0 ;
78807   float result;
78808
78809   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78810   arg2 = (float)jarg2;
78811   arg3 = (float)jarg3;
78812   arg4 = (float)jarg4;
78813   arg5 = (float)jarg5;
78814   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78815   if (!arg6) {
78816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78817     return 0;
78818   }
78819   {
78820     try {
78821       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78822     } catch (std::out_of_range& e) {
78823       {
78824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78825       };
78826     } catch (std::exception& e) {
78827       {
78828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78829       };
78830     } catch (Dali::DaliException e) {
78831       {
78832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78833       };
78834     } catch (...) {
78835       {
78836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78837       };
78838     }
78839   }
78840
78841   jresult = result;
78842   return jresult;
78843 }
78844
78845
78846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78847   void * jresult ;
78848   Dali::Toolkit::DefaultRuler *result = 0 ;
78849
78850   {
78851     try {
78852       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78853     } catch (std::out_of_range& e) {
78854       {
78855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78856       };
78857     } catch (std::exception& e) {
78858       {
78859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78860       };
78861     } catch (Dali::DaliException e) {
78862       {
78863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78864       };
78865     } catch (...) {
78866       {
78867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78868       };
78869     }
78870   }
78871
78872   jresult = (void *)result;
78873   return jresult;
78874 }
78875
78876
78877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78878   float jresult ;
78879   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78880   float arg2 ;
78881   float arg3 ;
78882   float result;
78883
78884   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78885   arg2 = (float)jarg2;
78886   arg3 = (float)jarg3;
78887   {
78888     try {
78889       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78890     } catch (std::out_of_range& e) {
78891       {
78892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78893       };
78894     } catch (std::exception& e) {
78895       {
78896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78897       };
78898     } catch (Dali::DaliException e) {
78899       {
78900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78901       };
78902     } catch (...) {
78903       {
78904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78905       };
78906     }
78907   }
78908
78909   jresult = result;
78910   return jresult;
78911 }
78912
78913
78914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78915   float jresult ;
78916   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78917   unsigned int arg2 ;
78918   unsigned int *arg3 = 0 ;
78919   bool arg4 ;
78920   float result;
78921
78922   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78923   arg2 = (unsigned int)jarg2;
78924   arg3 = (unsigned int *)jarg3;
78925   arg4 = jarg4 ? true : false;
78926   {
78927     try {
78928       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78929     } catch (std::out_of_range& e) {
78930       {
78931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78932       };
78933     } catch (std::exception& e) {
78934       {
78935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78936       };
78937     } catch (Dali::DaliException e) {
78938       {
78939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78940       };
78941     } catch (...) {
78942       {
78943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78944       };
78945     }
78946   }
78947
78948   jresult = result;
78949   return jresult;
78950 }
78951
78952
78953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78954   unsigned int jresult ;
78955   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78956   float arg2 ;
78957   bool arg3 ;
78958   unsigned int result;
78959
78960   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78961   arg2 = (float)jarg2;
78962   arg3 = jarg3 ? true : false;
78963   {
78964     try {
78965       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78966     } catch (std::out_of_range& e) {
78967       {
78968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78969       };
78970     } catch (std::exception& e) {
78971       {
78972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78973       };
78974     } catch (Dali::DaliException e) {
78975       {
78976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78977       };
78978     } catch (...) {
78979       {
78980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78981       };
78982     }
78983   }
78984
78985   jresult = result;
78986   return jresult;
78987 }
78988
78989
78990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78991   unsigned int jresult ;
78992   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78993   unsigned int result;
78994
78995   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78996   {
78997     try {
78998       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78999     } catch (std::out_of_range& e) {
79000       {
79001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (std::exception& e) {
79004       {
79005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79006       };
79007     } catch (Dali::DaliException e) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79010       };
79011     } catch (...) {
79012       {
79013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79014       };
79015     }
79016   }
79017
79018   jresult = result;
79019   return jresult;
79020 }
79021
79022
79023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79024   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79025
79026   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79027   {
79028     try {
79029       delete arg1;
79030     } catch (std::out_of_range& e) {
79031       {
79032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79033       };
79034     } catch (std::exception& e) {
79035       {
79036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79037       };
79038     } catch (Dali::DaliException e) {
79039       {
79040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79041       };
79042     } catch (...) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79045       };
79046     }
79047   }
79048
79049 }
79050
79051
79052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79053   void * jresult ;
79054   float arg1 ;
79055   Dali::Toolkit::FixedRuler *result = 0 ;
79056
79057   arg1 = (float)jarg1;
79058   {
79059     try {
79060       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79061     } catch (std::out_of_range& e) {
79062       {
79063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79064       };
79065     } catch (std::exception& e) {
79066       {
79067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79068       };
79069     } catch (Dali::DaliException e) {
79070       {
79071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79072       };
79073     } catch (...) {
79074       {
79075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79076       };
79077     }
79078   }
79079
79080   jresult = (void *)result;
79081   return jresult;
79082 }
79083
79084
79085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79086   void * jresult ;
79087   Dali::Toolkit::FixedRuler *result = 0 ;
79088
79089   {
79090     try {
79091       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79092     } catch (std::out_of_range& e) {
79093       {
79094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79095       };
79096     } catch (std::exception& e) {
79097       {
79098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79099       };
79100     } catch (Dali::DaliException e) {
79101       {
79102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79103       };
79104     } catch (...) {
79105       {
79106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79107       };
79108     }
79109   }
79110
79111   jresult = (void *)result;
79112   return jresult;
79113 }
79114
79115
79116 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79117   float jresult ;
79118   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79119   float arg2 ;
79120   float arg3 ;
79121   float result;
79122
79123   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79124   arg2 = (float)jarg2;
79125   arg3 = (float)jarg3;
79126   {
79127     try {
79128       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79129     } catch (std::out_of_range& e) {
79130       {
79131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79132       };
79133     } catch (std::exception& e) {
79134       {
79135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (Dali::DaliException e) {
79138       {
79139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79140       };
79141     } catch (...) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79144       };
79145     }
79146   }
79147
79148   jresult = result;
79149   return jresult;
79150 }
79151
79152
79153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79154   float jresult ;
79155   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79156   unsigned int arg2 ;
79157   unsigned int *arg3 = 0 ;
79158   bool arg4 ;
79159   float result;
79160
79161   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79162   arg2 = (unsigned int)jarg2;
79163   arg3 = (unsigned int *)jarg3;
79164   arg4 = jarg4 ? true : false;
79165   {
79166     try {
79167       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79168     } catch (std::out_of_range& e) {
79169       {
79170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79171       };
79172     } catch (std::exception& e) {
79173       {
79174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79175       };
79176     } catch (Dali::DaliException e) {
79177       {
79178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79179       };
79180     } catch (...) {
79181       {
79182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79183       };
79184     }
79185   }
79186
79187   jresult = result;
79188   return jresult;
79189 }
79190
79191
79192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79193   unsigned int jresult ;
79194   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79195   float arg2 ;
79196   bool arg3 ;
79197   unsigned int result;
79198
79199   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79200   arg2 = (float)jarg2;
79201   arg3 = jarg3 ? true : false;
79202   {
79203     try {
79204       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79205     } catch (std::out_of_range& e) {
79206       {
79207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79208       };
79209     } catch (std::exception& e) {
79210       {
79211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79212       };
79213     } catch (Dali::DaliException e) {
79214       {
79215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79216       };
79217     } catch (...) {
79218       {
79219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79220       };
79221     }
79222   }
79223
79224   jresult = result;
79225   return jresult;
79226 }
79227
79228
79229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79230   unsigned int jresult ;
79231   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79232   unsigned int result;
79233
79234   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79235   {
79236     try {
79237       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79238     } catch (std::out_of_range& e) {
79239       {
79240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79241       };
79242     } catch (std::exception& e) {
79243       {
79244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79245       };
79246     } catch (Dali::DaliException e) {
79247       {
79248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79249       };
79250     } catch (...) {
79251       {
79252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79253       };
79254     }
79255   }
79256
79257   jresult = result;
79258   return jresult;
79259 }
79260
79261
79262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79263   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79264
79265   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79266   {
79267     try {
79268       delete arg1;
79269     } catch (std::out_of_range& e) {
79270       {
79271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79272       };
79273     } catch (std::exception& e) {
79274       {
79275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79276       };
79277     } catch (Dali::DaliException e) {
79278       {
79279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79280       };
79281     } catch (...) {
79282       {
79283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79284       };
79285     }
79286   }
79287
79288 }
79289
79290
79291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79292   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79293   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79294
79295   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79296   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79297   if (arg1) (arg1)->scale = *arg2;
79298 }
79299
79300
79301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79302   void * jresult ;
79303   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79304   Dali::Toolkit::ClampState2D *result = 0 ;
79305
79306   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79307   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79308   jresult = (void *)result;
79309   return jresult;
79310 }
79311
79312
79313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79314   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79315   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79316
79317   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79318   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79319   if (arg1) (arg1)->position = *arg2;
79320 }
79321
79322
79323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79324   void * jresult ;
79325   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79326   Dali::Toolkit::ClampState2D *result = 0 ;
79327
79328   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79329   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79330   jresult = (void *)result;
79331   return jresult;
79332 }
79333
79334
79335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79336   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79337   Dali::Toolkit::ClampState arg2 ;
79338
79339   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79340   arg2 = (Dali::Toolkit::ClampState)jarg2;
79341   if (arg1) (arg1)->rotation = arg2;
79342 }
79343
79344
79345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79346   int jresult ;
79347   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79348   Dali::Toolkit::ClampState result;
79349
79350   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79351   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79352   jresult = (int)result;
79353   return jresult;
79354 }
79355
79356
79357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79358   void * jresult ;
79359   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79360
79361   {
79362     try {
79363       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79364     } catch (std::out_of_range& e) {
79365       {
79366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79367       };
79368     } catch (std::exception& e) {
79369       {
79370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79371       };
79372     } catch (Dali::DaliException e) {
79373       {
79374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79375       };
79376     } catch (...) {
79377       {
79378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79379       };
79380     }
79381   }
79382
79383   jresult = (void *)result;
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79389   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79390
79391   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79392   {
79393     try {
79394       delete arg1;
79395     } catch (std::out_of_range& e) {
79396       {
79397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79398       };
79399     } catch (std::exception& e) {
79400       {
79401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79402       };
79403     } catch (Dali::DaliException e) {
79404       {
79405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79406       };
79407     } catch (...) {
79408       {
79409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79410       };
79411     }
79412   }
79413
79414 }
79415
79416
79417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79418   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79419   Dali::Toolkit::SnapType arg2 ;
79420
79421   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79422   arg2 = (Dali::Toolkit::SnapType)jarg2;
79423   if (arg1) (arg1)->type = arg2;
79424 }
79425
79426
79427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79428   int jresult ;
79429   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79430   Dali::Toolkit::SnapType result;
79431
79432   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79433   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79434   jresult = (int)result;
79435   return jresult;
79436 }
79437
79438
79439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79440   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79441   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79442
79443   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79444   arg2 = (Dali::Vector2 *)jarg2;
79445   if (arg1) (arg1)->position = *arg2;
79446 }
79447
79448
79449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79450   void * jresult ;
79451   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79452   Dali::Vector2 *result = 0 ;
79453
79454   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79455   result = (Dali::Vector2 *)& ((arg1)->position);
79456   jresult = (void *)result;
79457   return jresult;
79458 }
79459
79460
79461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79462   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79463   float arg2 ;
79464
79465   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79466   arg2 = (float)jarg2;
79467   if (arg1) (arg1)->duration = arg2;
79468 }
79469
79470
79471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79472   float jresult ;
79473   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79474   float result;
79475
79476   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79477   result = (float) ((arg1)->duration);
79478   jresult = result;
79479   return jresult;
79480 }
79481
79482
79483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79484   void * jresult ;
79485   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79486
79487   {
79488     try {
79489       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79490     } catch (std::out_of_range& e) {
79491       {
79492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79493       };
79494     } catch (std::exception& e) {
79495       {
79496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79497       };
79498     } catch (Dali::DaliException e) {
79499       {
79500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79501       };
79502     } catch (...) {
79503       {
79504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79505       };
79506     }
79507   }
79508
79509   jresult = (void *)result;
79510   return jresult;
79511 }
79512
79513
79514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79515   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79516
79517   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79518   {
79519     try {
79520       delete arg1;
79521     } catch (std::out_of_range& e) {
79522       {
79523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79524       };
79525     } catch (std::exception& e) {
79526       {
79527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79528       };
79529     } catch (Dali::DaliException e) {
79530       {
79531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79532       };
79533     } catch (...) {
79534       {
79535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79536       };
79537     }
79538   }
79539
79540 }
79541
79542
79543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79544   int jresult ;
79545   int result;
79546
79547   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79548   jresult = (int)result;
79549   return jresult;
79550 }
79551
79552
79553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79554   int jresult ;
79555   int result;
79556
79557   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79558   jresult = (int)result;
79559   return jresult;
79560 }
79561
79562
79563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79564   int jresult ;
79565   int result;
79566
79567   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79568   jresult = (int)result;
79569   return jresult;
79570 }
79571
79572
79573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79574   int jresult ;
79575   int result;
79576
79577   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79578   jresult = (int)result;
79579   return jresult;
79580 }
79581
79582
79583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79584   int jresult ;
79585   int result;
79586
79587   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79588   jresult = (int)result;
79589   return jresult;
79590 }
79591
79592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79593   int jresult ;
79594   int result;
79595
79596   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79597   jresult = (int)result;
79598   return jresult;
79599 }
79600
79601
79602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79603   int jresult ;
79604   int result;
79605
79606   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79607   jresult = (int)result;
79608   return jresult;
79609 }
79610
79611
79612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79613   int jresult ;
79614   int result;
79615
79616   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79617   jresult = (int)result;
79618   return jresult;
79619 }
79620
79621
79622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79623   int jresult ;
79624   int result;
79625
79626   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79627   jresult = (int)result;
79628   return jresult;
79629 }
79630
79631
79632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79633   int jresult ;
79634   int result;
79635
79636   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79637   jresult = (int)result;
79638   return jresult;
79639 }
79640
79641
79642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79643   int jresult ;
79644   int result;
79645
79646   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79647   jresult = (int)result;
79648   return jresult;
79649 }
79650
79651
79652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79653   int jresult ;
79654   int result;
79655
79656   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79657   jresult = (int)result;
79658   return jresult;
79659 }
79660
79661
79662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79663   int jresult ;
79664   int result;
79665
79666   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79667   jresult = (int)result;
79668   return jresult;
79669 }
79670
79671
79672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79673   int jresult ;
79674   int result;
79675
79676   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79677   jresult = (int)result;
79678   return jresult;
79679 }
79680
79681
79682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79683   int jresult ;
79684   int result;
79685
79686   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79687   jresult = (int)result;
79688   return jresult;
79689 }
79690
79691
79692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79693   int jresult ;
79694   int result;
79695
79696   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79697   jresult = (int)result;
79698   return jresult;
79699 }
79700
79701
79702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79703   int jresult ;
79704   int result;
79705
79706   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79707   jresult = (int)result;
79708   return jresult;
79709 }
79710
79711
79712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79713   int jresult ;
79714   int result;
79715
79716   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79717   jresult = (int)result;
79718   return jresult;
79719 }
79720
79721
79722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79723   int jresult ;
79724   int result;
79725
79726   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79727   jresult = (int)result;
79728   return jresult;
79729 }
79730
79731
79732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79733   int jresult ;
79734   int result;
79735
79736   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79737   jresult = (int)result;
79738   return jresult;
79739 }
79740
79741
79742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79743   int jresult ;
79744   int result;
79745
79746   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79747   jresult = (int)result;
79748   return jresult;
79749 }
79750
79751
79752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79753   int jresult ;
79754   int result;
79755
79756   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79757   jresult = (int)result;
79758   return jresult;
79759 }
79760
79761
79762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79763   int jresult ;
79764   int result;
79765
79766   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79767   jresult = (int)result;
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79773   int jresult ;
79774   int result;
79775
79776   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79777   jresult = (int)result;
79778   return jresult;
79779 }
79780
79781
79782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79783   int jresult ;
79784   int result;
79785
79786   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79787   jresult = (int)result;
79788   return jresult;
79789 }
79790
79791
79792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79793   int jresult ;
79794   int result;
79795
79796   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79797   jresult = (int)result;
79798   return jresult;
79799 }
79800
79801
79802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79803   void * jresult ;
79804   Dali::Toolkit::ScrollView::Property *result = 0 ;
79805
79806   {
79807     try {
79808       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79809     } catch (std::out_of_range& e) {
79810       {
79811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79812       };
79813     } catch (std::exception& e) {
79814       {
79815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79816       };
79817     } catch (Dali::DaliException e) {
79818       {
79819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79820       };
79821     } catch (...) {
79822       {
79823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79824       };
79825     }
79826   }
79827
79828   jresult = (void *)result;
79829   return jresult;
79830 }
79831
79832
79833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79834   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79835
79836   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79837   {
79838     try {
79839       delete arg1;
79840     } catch (std::out_of_range& e) {
79841       {
79842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79843       };
79844     } catch (std::exception& e) {
79845       {
79846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79847       };
79848     } catch (Dali::DaliException e) {
79849       {
79850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79851       };
79852     } catch (...) {
79853       {
79854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79855       };
79856     }
79857   }
79858
79859 }
79860
79861
79862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79863   void * jresult ;
79864   Dali::Toolkit::ScrollView *result = 0 ;
79865
79866   {
79867     try {
79868       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79869     } catch (std::out_of_range& e) {
79870       {
79871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79872       };
79873     } catch (std::exception& e) {
79874       {
79875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79876       };
79877     } catch (Dali::DaliException e) {
79878       {
79879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79880       };
79881     } catch (...) {
79882       {
79883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79884       };
79885     }
79886   }
79887
79888   jresult = (void *)result;
79889   return jresult;
79890 }
79891
79892
79893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79894   void * jresult ;
79895   Dali::Toolkit::ScrollView *arg1 = 0 ;
79896   Dali::Toolkit::ScrollView *result = 0 ;
79897
79898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79899   if (!arg1) {
79900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79901     return 0;
79902   }
79903   {
79904     try {
79905       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79906     } catch (std::out_of_range& e) {
79907       {
79908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79909       };
79910     } catch (std::exception& e) {
79911       {
79912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79913       };
79914     } catch (Dali::DaliException e) {
79915       {
79916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79917       };
79918     } catch (...) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79921       };
79922     }
79923   }
79924
79925   jresult = (void *)result;
79926   return jresult;
79927 }
79928
79929
79930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79931   void * jresult ;
79932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79933   Dali::Toolkit::ScrollView *arg2 = 0 ;
79934   Dali::Toolkit::ScrollView *result = 0 ;
79935
79936   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79937   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79938   if (!arg2) {
79939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79940     return 0;
79941   }
79942   {
79943     try {
79944       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79945     } catch (std::out_of_range& e) {
79946       {
79947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (std::exception& e) {
79950       {
79951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79952       };
79953     } catch (Dali::DaliException e) {
79954       {
79955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79956       };
79957     } catch (...) {
79958       {
79959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79960       };
79961     }
79962   }
79963
79964   jresult = (void *)result;
79965   return jresult;
79966 }
79967
79968
79969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79970   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79971
79972   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79973   {
79974     try {
79975       delete arg1;
79976     } catch (std::out_of_range& e) {
79977       {
79978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79979       };
79980     } catch (std::exception& e) {
79981       {
79982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79983       };
79984     } catch (Dali::DaliException e) {
79985       {
79986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79987       };
79988     } catch (...) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79991       };
79992     }
79993   }
79994
79995 }
79996
79997
79998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79999   void * jresult ;
80000   Dali::Toolkit::ScrollView result;
80001
80002   {
80003     try {
80004       result = Dali::Toolkit::ScrollView::New();
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (Dali::DaliException e) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80016       };
80017     } catch (...) {
80018       {
80019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80020       };
80021     }
80022   }
80023
80024   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80025   return jresult;
80026 }
80027
80028
80029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80030   void * jresult ;
80031   Dali::BaseHandle arg1 ;
80032   Dali::BaseHandle *argp1 ;
80033   Dali::Toolkit::ScrollView result;
80034
80035   argp1 = (Dali::BaseHandle *)jarg1;
80036   if (!argp1) {
80037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80038     return 0;
80039   }
80040   arg1 = *argp1;
80041   {
80042     try {
80043       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80044     } catch (std::out_of_range& e) {
80045       {
80046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80047       };
80048     } catch (std::exception& e) {
80049       {
80050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80051       };
80052     } catch (Dali::DaliException e) {
80053       {
80054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80055       };
80056     } catch (...) {
80057       {
80058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80059       };
80060     }
80061   }
80062
80063   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80064   return jresult;
80065 }
80066
80067
80068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80069   void * jresult ;
80070   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80071   Dali::AlphaFunction result;
80072
80073   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80074   {
80075     try {
80076       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80077     } catch (std::out_of_range& e) {
80078       {
80079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80080       };
80081     } catch (std::exception& e) {
80082       {
80083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80084       };
80085     } catch (Dali::DaliException e) {
80086       {
80087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80088       };
80089     } catch (...) {
80090       {
80091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80092       };
80093     }
80094   }
80095
80096   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80097   return jresult;
80098 }
80099
80100
80101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80102   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80103   Dali::AlphaFunction arg2 ;
80104   Dali::AlphaFunction *argp2 ;
80105
80106   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80107   argp2 = (Dali::AlphaFunction *)jarg2;
80108   if (!argp2) {
80109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80110     return ;
80111   }
80112   arg2 = *argp2;
80113   {
80114     try {
80115       (arg1)->SetScrollSnapAlphaFunction(arg2);
80116     } catch (std::out_of_range& e) {
80117       {
80118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80119       };
80120     } catch (std::exception& e) {
80121       {
80122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80123       };
80124     } catch (Dali::DaliException e) {
80125       {
80126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80127       };
80128     } catch (...) {
80129       {
80130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80131       };
80132     }
80133   }
80134
80135 }
80136
80137
80138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80139   void * jresult ;
80140   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80141   Dali::AlphaFunction result;
80142
80143   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80144   {
80145     try {
80146       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80147     } catch (std::out_of_range& e) {
80148       {
80149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80150       };
80151     } catch (std::exception& e) {
80152       {
80153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80154       };
80155     } catch (Dali::DaliException e) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80158       };
80159     } catch (...) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80162       };
80163     }
80164   }
80165
80166   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80167   return jresult;
80168 }
80169
80170
80171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80172   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80173   Dali::AlphaFunction arg2 ;
80174   Dali::AlphaFunction *argp2 ;
80175
80176   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80177   argp2 = (Dali::AlphaFunction *)jarg2;
80178   if (!argp2) {
80179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80180     return ;
80181   }
80182   arg2 = *argp2;
80183   {
80184     try {
80185       (arg1)->SetScrollFlickAlphaFunction(arg2);
80186     } catch (std::out_of_range& e) {
80187       {
80188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80189       };
80190     } catch (std::exception& e) {
80191       {
80192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80193       };
80194     } catch (Dali::DaliException e) {
80195       {
80196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80197       };
80198     } catch (...) {
80199       {
80200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80201       };
80202     }
80203   }
80204
80205 }
80206
80207
80208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80209   float jresult ;
80210   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80211   float result;
80212
80213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80214   {
80215     try {
80216       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80217     } catch (std::out_of_range& e) {
80218       {
80219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80220       };
80221     } catch (std::exception& e) {
80222       {
80223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80224       };
80225     } catch (Dali::DaliException e) {
80226       {
80227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80228       };
80229     } catch (...) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80232       };
80233     }
80234   }
80235
80236   jresult = result;
80237   return jresult;
80238 }
80239
80240
80241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80243   float arg2 ;
80244
80245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80246   arg2 = (float)jarg2;
80247   {
80248     try {
80249       (arg1)->SetScrollSnapDuration(arg2);
80250     } catch (std::out_of_range& e) {
80251       {
80252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80253       };
80254     } catch (std::exception& e) {
80255       {
80256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80257       };
80258     } catch (Dali::DaliException e) {
80259       {
80260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80261       };
80262     } catch (...) {
80263       {
80264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80265       };
80266     }
80267   }
80268
80269 }
80270
80271
80272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80273   float jresult ;
80274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80275   float result;
80276
80277   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80278   {
80279     try {
80280       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80281     } catch (std::out_of_range& e) {
80282       {
80283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80284       };
80285     } catch (std::exception& e) {
80286       {
80287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80288       };
80289     } catch (Dali::DaliException e) {
80290       {
80291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80292       };
80293     } catch (...) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80296       };
80297     }
80298   }
80299
80300   jresult = result;
80301   return jresult;
80302 }
80303
80304
80305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80306   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80307   float arg2 ;
80308
80309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80310   arg2 = (float)jarg2;
80311   {
80312     try {
80313       (arg1)->SetScrollFlickDuration(arg2);
80314     } catch (std::out_of_range& e) {
80315       {
80316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80317       };
80318     } catch (std::exception& e) {
80319       {
80320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80321       };
80322     } catch (Dali::DaliException e) {
80323       {
80324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80325       };
80326     } catch (...) {
80327       {
80328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80329       };
80330     }
80331   }
80332
80333 }
80334
80335
80336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80337   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80338   Dali::Toolkit::RulerPtr arg2 ;
80339   Dali::Toolkit::RulerPtr *argp2 ;
80340
80341   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80342   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80343   if (!argp2) {
80344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80345     return ;
80346   }
80347   arg2 = *argp2;
80348   {
80349     try {
80350       (arg1)->SetRulerX(arg2);
80351     } catch (std::out_of_range& e) {
80352       {
80353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80354       };
80355     } catch (std::exception& e) {
80356       {
80357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80358       };
80359     } catch (Dali::DaliException e) {
80360       {
80361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80362       };
80363     } catch (...) {
80364       {
80365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80366       };
80367     }
80368   }
80369
80370 }
80371
80372
80373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80374   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80375   Dali::Toolkit::RulerPtr arg2 ;
80376   Dali::Toolkit::RulerPtr *argp2 ;
80377
80378   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80379   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80380   if (!argp2) {
80381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80382     return ;
80383   }
80384   arg2 = *argp2;
80385   {
80386     try {
80387       (arg1)->SetRulerY(arg2);
80388     } catch (std::out_of_range& e) {
80389       {
80390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80391       };
80392     } catch (std::exception& e) {
80393       {
80394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80395       };
80396     } catch (Dali::DaliException e) {
80397       {
80398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80399       };
80400     } catch (...) {
80401       {
80402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80403       };
80404     }
80405   }
80406
80407 }
80408
80409
80410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80412   bool arg2 ;
80413
80414   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80415   arg2 = jarg2 ? true : false;
80416   {
80417     try {
80418       (arg1)->SetScrollSensitive(arg2);
80419     } catch (std::out_of_range& e) {
80420       {
80421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80422       };
80423     } catch (std::exception& e) {
80424       {
80425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80426       };
80427     } catch (Dali::DaliException e) {
80428       {
80429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80430       };
80431     } catch (...) {
80432       {
80433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80434       };
80435     }
80436   }
80437
80438 }
80439
80440
80441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80443   float arg2 ;
80444   float arg3 ;
80445
80446   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80447   arg2 = (float)jarg2;
80448   arg3 = (float)jarg3;
80449   {
80450     try {
80451       (arg1)->SetMaxOvershoot(arg2,arg3);
80452     } catch (std::out_of_range& e) {
80453       {
80454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80455       };
80456     } catch (std::exception& e) {
80457       {
80458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80459       };
80460     } catch (Dali::DaliException e) {
80461       {
80462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80463       };
80464     } catch (...) {
80465       {
80466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80467       };
80468     }
80469   }
80470
80471 }
80472
80473
80474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80475   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80476   Dali::AlphaFunction arg2 ;
80477   Dali::AlphaFunction *argp2 ;
80478
80479   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80480   argp2 = (Dali::AlphaFunction *)jarg2;
80481   if (!argp2) {
80482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80483     return ;
80484   }
80485   arg2 = *argp2;
80486   {
80487     try {
80488       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80489     } catch (std::out_of_range& e) {
80490       {
80491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80492       };
80493     } catch (std::exception& e) {
80494       {
80495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80496       };
80497     } catch (Dali::DaliException e) {
80498       {
80499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80500       };
80501     } catch (...) {
80502       {
80503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80504       };
80505     }
80506   }
80507
80508 }
80509
80510
80511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80512   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80513   float arg2 ;
80514
80515   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80516   arg2 = (float)jarg2;
80517   {
80518     try {
80519       (arg1)->SetSnapOvershootDuration(arg2);
80520     } catch (std::out_of_range& e) {
80521       {
80522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80523       };
80524     } catch (std::exception& e) {
80525       {
80526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80527       };
80528     } catch (Dali::DaliException e) {
80529       {
80530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80531       };
80532     } catch (...) {
80533       {
80534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80535       };
80536     }
80537   }
80538
80539 }
80540
80541
80542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80543   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80544   bool arg2 ;
80545
80546   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80547   arg2 = jarg2 ? true : false;
80548   {
80549     try {
80550       (arg1)->SetActorAutoSnap(arg2);
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (Dali::DaliException e) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80566       };
80567     }
80568   }
80569
80570 }
80571
80572
80573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80575   bool arg2 ;
80576
80577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80578   arg2 = jarg2 ? true : false;
80579   {
80580     try {
80581       (arg1)->SetWrapMode(arg2);
80582     } catch (std::out_of_range& e) {
80583       {
80584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80585       };
80586     } catch (std::exception& e) {
80587       {
80588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80589       };
80590     } catch (Dali::DaliException e) {
80591       {
80592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80593       };
80594     } catch (...) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80597       };
80598     }
80599   }
80600
80601 }
80602
80603
80604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80605   int jresult ;
80606   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80607   int result;
80608
80609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80610   {
80611     try {
80612       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80613     } catch (std::out_of_range& e) {
80614       {
80615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80616       };
80617     } catch (std::exception& e) {
80618       {
80619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80620       };
80621     } catch (Dali::DaliException e) {
80622       {
80623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80624       };
80625     } catch (...) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80628       };
80629     }
80630   }
80631
80632   jresult = result;
80633   return jresult;
80634 }
80635
80636
80637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80639   int arg2 ;
80640
80641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80642   arg2 = (int)jarg2;
80643   {
80644     try {
80645       (arg1)->SetScrollUpdateDistance(arg2);
80646     } catch (std::out_of_range& e) {
80647       {
80648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80649       };
80650     } catch (std::exception& e) {
80651       {
80652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80653       };
80654     } catch (Dali::DaliException e) {
80655       {
80656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80657       };
80658     } catch (...) {
80659       {
80660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80661       };
80662     }
80663   }
80664
80665 }
80666
80667
80668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80669   unsigned int jresult ;
80670   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80671   bool result;
80672
80673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80674   {
80675     try {
80676       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80677     } catch (std::out_of_range& e) {
80678       {
80679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80680       };
80681     } catch (std::exception& e) {
80682       {
80683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80684       };
80685     } catch (Dali::DaliException e) {
80686       {
80687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80688       };
80689     } catch (...) {
80690       {
80691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80692       };
80693     }
80694   }
80695
80696   jresult = result;
80697   return jresult;
80698 }
80699
80700
80701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80702   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80703   bool arg2 ;
80704
80705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80706   arg2 = jarg2 ? true : false;
80707   {
80708     try {
80709       (arg1)->SetAxisAutoLock(arg2);
80710     } catch (std::out_of_range& e) {
80711       {
80712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80713       };
80714     } catch (std::exception& e) {
80715       {
80716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80717       };
80718     } catch (Dali::DaliException e) {
80719       {
80720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80721       };
80722     } catch (...) {
80723       {
80724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80725       };
80726     }
80727   }
80728
80729 }
80730
80731
80732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80733   float jresult ;
80734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80735   float result;
80736
80737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80738   {
80739     try {
80740       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80741     } catch (std::out_of_range& e) {
80742       {
80743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80744       };
80745     } catch (std::exception& e) {
80746       {
80747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80748       };
80749     } catch (Dali::DaliException e) {
80750       {
80751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80752       };
80753     } catch (...) {
80754       {
80755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80756       };
80757     }
80758   }
80759
80760   jresult = result;
80761   return jresult;
80762 }
80763
80764
80765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80766   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80767   float arg2 ;
80768
80769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80770   arg2 = (float)jarg2;
80771   {
80772     try {
80773       (arg1)->SetAxisAutoLockGradient(arg2);
80774     } catch (std::out_of_range& e) {
80775       {
80776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80777       };
80778     } catch (std::exception& e) {
80779       {
80780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80781       };
80782     } catch (Dali::DaliException e) {
80783       {
80784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80785       };
80786     } catch (...) {
80787       {
80788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80789       };
80790     }
80791   }
80792
80793 }
80794
80795
80796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80797   float jresult ;
80798   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80799   float result;
80800
80801   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80802   {
80803     try {
80804       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80805     } catch (std::out_of_range& e) {
80806       {
80807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80808       };
80809     } catch (std::exception& e) {
80810       {
80811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80812       };
80813     } catch (Dali::DaliException e) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80816       };
80817     } catch (...) {
80818       {
80819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80820       };
80821     }
80822   }
80823
80824   jresult = result;
80825   return jresult;
80826 }
80827
80828
80829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80830   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80831   float arg2 ;
80832
80833   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80834   arg2 = (float)jarg2;
80835   {
80836     try {
80837       (arg1)->SetFrictionCoefficient(arg2);
80838     } catch (std::out_of_range& e) {
80839       {
80840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80841       };
80842     } catch (std::exception& e) {
80843       {
80844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80845       };
80846     } catch (Dali::DaliException e) {
80847       {
80848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80849       };
80850     } catch (...) {
80851       {
80852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80853       };
80854     }
80855   }
80856
80857 }
80858
80859
80860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80861   float jresult ;
80862   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80863   float result;
80864
80865   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80866   {
80867     try {
80868       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80869     } catch (std::out_of_range& e) {
80870       {
80871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80872       };
80873     } catch (std::exception& e) {
80874       {
80875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80876       };
80877     } catch (Dali::DaliException e) {
80878       {
80879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80880       };
80881     } catch (...) {
80882       {
80883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80884       };
80885     }
80886   }
80887
80888   jresult = result;
80889   return jresult;
80890 }
80891
80892
80893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80894   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80895   float arg2 ;
80896
80897   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80898   arg2 = (float)jarg2;
80899   {
80900     try {
80901       (arg1)->SetFlickSpeedCoefficient(arg2);
80902     } catch (std::out_of_range& e) {
80903       {
80904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80905       };
80906     } catch (std::exception& e) {
80907       {
80908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80909       };
80910     } catch (Dali::DaliException e) {
80911       {
80912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80913       };
80914     } catch (...) {
80915       {
80916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80917       };
80918     }
80919   }
80920
80921 }
80922
80923
80924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80925   void * jresult ;
80926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80927   Dali::Vector2 result;
80928
80929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80930   {
80931     try {
80932       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80933     } catch (std::out_of_range& e) {
80934       {
80935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80936       };
80937     } catch (std::exception& e) {
80938       {
80939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80940       };
80941     } catch (Dali::DaliException e) {
80942       {
80943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80944       };
80945     } catch (...) {
80946       {
80947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80948       };
80949     }
80950   }
80951
80952   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80953   return jresult;
80954 }
80955
80956
80957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80958   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80959   Dali::Vector2 *arg2 = 0 ;
80960
80961   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80962   arg2 = (Dali::Vector2 *)jarg2;
80963   if (!arg2) {
80964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80965     return ;
80966   }
80967   {
80968     try {
80969       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80970     } catch (std::out_of_range& e) {
80971       {
80972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80973       };
80974     } catch (std::exception& e) {
80975       {
80976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80977       };
80978     } catch (Dali::DaliException e) {
80979       {
80980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80981       };
80982     } catch (...) {
80983       {
80984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80985       };
80986     }
80987   }
80988
80989 }
80990
80991
80992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80993   float jresult ;
80994   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80995   float result;
80996
80997   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80998   {
80999     try {
81000       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81001     } catch (std::out_of_range& e) {
81002       {
81003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81004       };
81005     } catch (std::exception& e) {
81006       {
81007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81008       };
81009     } catch (Dali::DaliException e) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81012       };
81013     } catch (...) {
81014       {
81015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81016       };
81017     }
81018   }
81019
81020   jresult = result;
81021   return jresult;
81022 }
81023
81024
81025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81026   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81027   float arg2 ;
81028
81029   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81030   arg2 = (float)jarg2;
81031   {
81032     try {
81033       (arg1)->SetMinimumSpeedForFlick(arg2);
81034     } catch (std::out_of_range& e) {
81035       {
81036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81037       };
81038     } catch (std::exception& e) {
81039       {
81040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81041       };
81042     } catch (Dali::DaliException e) {
81043       {
81044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81045       };
81046     } catch (...) {
81047       {
81048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81049       };
81050     }
81051   }
81052
81053 }
81054
81055
81056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81057   float jresult ;
81058   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81059   float result;
81060
81061   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81062   {
81063     try {
81064       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81065     } catch (std::out_of_range& e) {
81066       {
81067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81068       };
81069     } catch (std::exception& e) {
81070       {
81071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81072       };
81073     } catch (Dali::DaliException e) {
81074       {
81075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81076       };
81077     } catch (...) {
81078       {
81079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81080       };
81081     }
81082   }
81083
81084   jresult = result;
81085   return jresult;
81086 }
81087
81088
81089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81090   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81091   float arg2 ;
81092
81093   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81094   arg2 = (float)jarg2;
81095   {
81096     try {
81097       (arg1)->SetMaxFlickSpeed(arg2);
81098     } catch (std::out_of_range& e) {
81099       {
81100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81101       };
81102     } catch (std::exception& e) {
81103       {
81104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81105       };
81106     } catch (Dali::DaliException e) {
81107       {
81108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81109       };
81110     } catch (...) {
81111       {
81112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81113       };
81114     }
81115   }
81116
81117 }
81118
81119
81120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81121   void * jresult ;
81122   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81123   Dali::Vector2 result;
81124
81125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81126   {
81127     try {
81128       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81129     } catch (std::out_of_range& e) {
81130       {
81131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81132       };
81133     } catch (std::exception& e) {
81134       {
81135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81136       };
81137     } catch (Dali::DaliException e) {
81138       {
81139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81140       };
81141     } catch (...) {
81142       {
81143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81144       };
81145     }
81146   }
81147
81148   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81149   return jresult;
81150 }
81151
81152
81153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81154   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81155   Dali::Vector2 arg2 ;
81156   Dali::Vector2 *argp2 ;
81157
81158   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81159   argp2 = (Dali::Vector2 *)jarg2;
81160   if (!argp2) {
81161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81162     return ;
81163   }
81164   arg2 = *argp2;
81165   {
81166     try {
81167       (arg1)->SetWheelScrollDistanceStep(arg2);
81168     } catch (std::out_of_range& e) {
81169       {
81170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81171       };
81172     } catch (std::exception& e) {
81173       {
81174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81175       };
81176     } catch (Dali::DaliException e) {
81177       {
81178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81179       };
81180     } catch (...) {
81181       {
81182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81183       };
81184     }
81185   }
81186
81187 }
81188
81189
81190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81191   void * jresult ;
81192   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81193   Dali::Vector2 result;
81194
81195   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81196   {
81197     try {
81198       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81199     } catch (std::out_of_range& e) {
81200       {
81201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81202       };
81203     } catch (std::exception& e) {
81204       {
81205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81206       };
81207     } catch (Dali::DaliException e) {
81208       {
81209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81210       };
81211     } catch (...) {
81212       {
81213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81214       };
81215     }
81216   }
81217
81218   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81219   return jresult;
81220 }
81221
81222
81223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81224   unsigned int jresult ;
81225   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81226   unsigned int result;
81227
81228   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81229   {
81230     try {
81231       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81232     } catch (std::out_of_range& e) {
81233       {
81234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81235       };
81236     } catch (std::exception& e) {
81237       {
81238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81239       };
81240     } catch (Dali::DaliException e) {
81241       {
81242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81243       };
81244     } catch (...) {
81245       {
81246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81247       };
81248     }
81249   }
81250
81251   jresult = result;
81252   return jresult;
81253 }
81254
81255
81256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81257   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81258   Dali::Vector2 *arg2 = 0 ;
81259
81260   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81261   arg2 = (Dali::Vector2 *)jarg2;
81262   if (!arg2) {
81263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81264     return ;
81265   }
81266   {
81267     try {
81268       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81269     } catch (std::out_of_range& e) {
81270       {
81271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81272       };
81273     } catch (std::exception& e) {
81274       {
81275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81276       };
81277     } catch (Dali::DaliException e) {
81278       {
81279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81280       };
81281     } catch (...) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81284       };
81285     }
81286   }
81287
81288 }
81289
81290
81291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81292   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81293   Dali::Vector2 *arg2 = 0 ;
81294   float arg3 ;
81295
81296   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81297   arg2 = (Dali::Vector2 *)jarg2;
81298   if (!arg2) {
81299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81300     return ;
81301   }
81302   arg3 = (float)jarg3;
81303   {
81304     try {
81305       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81306     } catch (std::out_of_range& e) {
81307       {
81308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81309       };
81310     } catch (std::exception& e) {
81311       {
81312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81313       };
81314     } catch (Dali::DaliException e) {
81315       {
81316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81317       };
81318     } catch (...) {
81319       {
81320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81321       };
81322     }
81323   }
81324
81325 }
81326
81327
81328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81330   Dali::Vector2 *arg2 = 0 ;
81331   float arg3 ;
81332   Dali::AlphaFunction arg4 ;
81333   Dali::AlphaFunction *argp4 ;
81334
81335   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81336   arg2 = (Dali::Vector2 *)jarg2;
81337   if (!arg2) {
81338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81339     return ;
81340   }
81341   arg3 = (float)jarg3;
81342   argp4 = (Dali::AlphaFunction *)jarg4;
81343   if (!argp4) {
81344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81345     return ;
81346   }
81347   arg4 = *argp4;
81348   {
81349     try {
81350       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81351     } catch (std::out_of_range& e) {
81352       {
81353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81354       };
81355     } catch (std::exception& e) {
81356       {
81357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81358       };
81359     } catch (Dali::DaliException e) {
81360       {
81361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81362       };
81363     } catch (...) {
81364       {
81365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81366       };
81367     }
81368   }
81369
81370 }
81371
81372
81373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81374   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81375   Dali::Vector2 *arg2 = 0 ;
81376   float arg3 ;
81377   Dali::Toolkit::DirectionBias arg4 ;
81378   Dali::Toolkit::DirectionBias arg5 ;
81379
81380   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81381   arg2 = (Dali::Vector2 *)jarg2;
81382   if (!arg2) {
81383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81384     return ;
81385   }
81386   arg3 = (float)jarg3;
81387   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81388   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81389   {
81390     try {
81391       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81392     } catch (std::out_of_range& e) {
81393       {
81394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81395       };
81396     } catch (std::exception& e) {
81397       {
81398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81399       };
81400     } catch (Dali::DaliException e) {
81401       {
81402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81403       };
81404     } catch (...) {
81405       {
81406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81407       };
81408     }
81409   }
81410
81411 }
81412
81413
81414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81415   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81416   Dali::Vector2 *arg2 = 0 ;
81417   float arg3 ;
81418   Dali::AlphaFunction arg4 ;
81419   Dali::Toolkit::DirectionBias arg5 ;
81420   Dali::Toolkit::DirectionBias arg6 ;
81421   Dali::AlphaFunction *argp4 ;
81422
81423   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81424   arg2 = (Dali::Vector2 *)jarg2;
81425   if (!arg2) {
81426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81427     return ;
81428   }
81429   arg3 = (float)jarg3;
81430   argp4 = (Dali::AlphaFunction *)jarg4;
81431   if (!argp4) {
81432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81433     return ;
81434   }
81435   arg4 = *argp4;
81436   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81437   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81438   {
81439     try {
81440       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81441     } catch (std::out_of_range& e) {
81442       {
81443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81444       };
81445     } catch (std::exception& e) {
81446       {
81447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81448       };
81449     } catch (Dali::DaliException e) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81452       };
81453     } catch (...) {
81454       {
81455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81456       };
81457     }
81458   }
81459
81460 }
81461
81462
81463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81464   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81465   unsigned int arg2 ;
81466
81467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81468   arg2 = (unsigned int)jarg2;
81469   {
81470     try {
81471       (arg1)->ScrollTo(arg2);
81472     } catch (std::out_of_range& e) {
81473       {
81474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81475       };
81476     } catch (std::exception& e) {
81477       {
81478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (Dali::DaliException e) {
81481       {
81482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81483       };
81484     } catch (...) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81487       };
81488     }
81489   }
81490
81491 }
81492
81493
81494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81495   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81496   unsigned int arg2 ;
81497   float arg3 ;
81498
81499   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81500   arg2 = (unsigned int)jarg2;
81501   arg3 = (float)jarg3;
81502   {
81503     try {
81504       (arg1)->ScrollTo(arg2,arg3);
81505     } catch (std::out_of_range& e) {
81506       {
81507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (std::exception& e) {
81510       {
81511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81512       };
81513     } catch (Dali::DaliException e) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81516       };
81517     } catch (...) {
81518       {
81519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81520       };
81521     }
81522   }
81523
81524 }
81525
81526
81527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81528   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81529   unsigned int arg2 ;
81530   float arg3 ;
81531   Dali::Toolkit::DirectionBias arg4 ;
81532
81533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81534   arg2 = (unsigned int)jarg2;
81535   arg3 = (float)jarg3;
81536   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81537   {
81538     try {
81539       (arg1)->ScrollTo(arg2,arg3,arg4);
81540     } catch (std::out_of_range& e) {
81541       {
81542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81543       };
81544     } catch (std::exception& e) {
81545       {
81546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81547       };
81548     } catch (Dali::DaliException e) {
81549       {
81550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81551       };
81552     } catch (...) {
81553       {
81554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81555       };
81556     }
81557   }
81558
81559 }
81560
81561
81562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81564   Dali::Actor *arg2 = 0 ;
81565
81566   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81567   arg2 = (Dali::Actor *)jarg2;
81568   if (!arg2) {
81569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81570     return ;
81571   }
81572   {
81573     try {
81574       (arg1)->ScrollTo(*arg2);
81575     } catch (std::out_of_range& e) {
81576       {
81577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81578       };
81579     } catch (std::exception& e) {
81580       {
81581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81582       };
81583     } catch (Dali::DaliException e) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81586       };
81587     } catch (...) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81590       };
81591     }
81592   }
81593
81594 }
81595
81596
81597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81599   Dali::Actor *arg2 = 0 ;
81600   float arg3 ;
81601
81602   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81603   arg2 = (Dali::Actor *)jarg2;
81604   if (!arg2) {
81605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81606     return ;
81607   }
81608   arg3 = (float)jarg3;
81609   {
81610     try {
81611       (arg1)->ScrollTo(*arg2,arg3);
81612     } catch (std::out_of_range& e) {
81613       {
81614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81615       };
81616     } catch (std::exception& e) {
81617       {
81618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81619       };
81620     } catch (Dali::DaliException e) {
81621       {
81622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81623       };
81624     } catch (...) {
81625       {
81626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81627       };
81628     }
81629   }
81630
81631 }
81632
81633
81634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81635   unsigned int jresult ;
81636   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81637   bool result;
81638
81639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81640   {
81641     try {
81642       result = (bool)(arg1)->ScrollToSnapPoint();
81643     } catch (std::out_of_range& e) {
81644       {
81645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81646       };
81647     } catch (std::exception& e) {
81648       {
81649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81650       };
81651     } catch (Dali::DaliException e) {
81652       {
81653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81654       };
81655     } catch (...) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81658       };
81659     }
81660   }
81661
81662   jresult = result;
81663   return jresult;
81664 }
81665
81666
81667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81668   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81669   Dali::Constraint arg2 ;
81670   Dali::Constraint *argp2 ;
81671
81672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81673   argp2 = (Dali::Constraint *)jarg2;
81674   if (!argp2) {
81675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81676     return ;
81677   }
81678   arg2 = *argp2;
81679   {
81680     try {
81681       (arg1)->ApplyConstraintToChildren(arg2);
81682     } catch (std::out_of_range& e) {
81683       {
81684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81685       };
81686     } catch (std::exception& e) {
81687       {
81688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81689       };
81690     } catch (Dali::DaliException e) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81693       };
81694     } catch (...) {
81695       {
81696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81697       };
81698     }
81699   }
81700
81701 }
81702
81703
81704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81706
81707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81708   {
81709     try {
81710       (arg1)->RemoveConstraintsFromChildren();
81711     } catch (std::out_of_range& e) {
81712       {
81713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81714       };
81715     } catch (std::exception& e) {
81716       {
81717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81718       };
81719     } catch (Dali::DaliException e) {
81720       {
81721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81722       };
81723     } catch (...) {
81724       {
81725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81726       };
81727     }
81728   }
81729
81730 }
81731
81732
81733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81735   Dali::Toolkit::ScrollViewEffect arg2 ;
81736   Dali::Toolkit::ScrollViewEffect *argp2 ;
81737
81738   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81739   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81740   if (!argp2) {
81741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81742     return ;
81743   }
81744   arg2 = *argp2;
81745   {
81746     try {
81747       (arg1)->ApplyEffect(arg2);
81748     } catch (std::out_of_range& e) {
81749       {
81750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81751       };
81752     } catch (std::exception& e) {
81753       {
81754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81755       };
81756     } catch (Dali::DaliException e) {
81757       {
81758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81759       };
81760     } catch (...) {
81761       {
81762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81763       };
81764     }
81765   }
81766
81767 }
81768
81769
81770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81772   Dali::Toolkit::ScrollViewEffect arg2 ;
81773   Dali::Toolkit::ScrollViewEffect *argp2 ;
81774
81775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81776   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81777   if (!argp2) {
81778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81779     return ;
81780   }
81781   arg2 = *argp2;
81782   {
81783     try {
81784       (arg1)->RemoveEffect(arg2);
81785     } catch (std::out_of_range& e) {
81786       {
81787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81788       };
81789     } catch (std::exception& e) {
81790       {
81791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81792       };
81793     } catch (Dali::DaliException e) {
81794       {
81795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81796       };
81797     } catch (...) {
81798       {
81799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81800       };
81801     }
81802   }
81803
81804 }
81805
81806
81807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81808   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81809
81810   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81811   {
81812     try {
81813       (arg1)->RemoveAllEffects();
81814     } catch (std::out_of_range& e) {
81815       {
81816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81817       };
81818     } catch (std::exception& e) {
81819       {
81820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81821       };
81822     } catch (Dali::DaliException e) {
81823       {
81824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81825       };
81826     } catch (...) {
81827       {
81828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81829       };
81830     }
81831   }
81832
81833 }
81834
81835
81836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81838   Dali::Actor arg2 ;
81839   Dali::Actor *argp2 ;
81840
81841   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81842   argp2 = (Dali::Actor *)jarg2;
81843   if (!argp2) {
81844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81845     return ;
81846   }
81847   arg2 = *argp2;
81848   {
81849     try {
81850       (arg1)->BindActor(arg2);
81851     } catch (std::out_of_range& e) {
81852       {
81853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81854       };
81855     } catch (std::exception& e) {
81856       {
81857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81858       };
81859     } catch (Dali::DaliException e) {
81860       {
81861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81862       };
81863     } catch (...) {
81864       {
81865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81866       };
81867     }
81868   }
81869
81870 }
81871
81872
81873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81874   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81875   Dali::Actor arg2 ;
81876   Dali::Actor *argp2 ;
81877
81878   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81879   argp2 = (Dali::Actor *)jarg2;
81880   if (!argp2) {
81881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81882     return ;
81883   }
81884   arg2 = *argp2;
81885   {
81886     try {
81887       (arg1)->UnbindActor(arg2);
81888     } catch (std::out_of_range& e) {
81889       {
81890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81891       };
81892     } catch (std::exception& e) {
81893       {
81894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81895       };
81896     } catch (Dali::DaliException e) {
81897       {
81898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81899       };
81900     } catch (...) {
81901       {
81902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81903       };
81904     }
81905   }
81906
81907 }
81908
81909
81910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81911   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81912   Dali::Radian arg2 ;
81913   Dali::Radian arg3 ;
81914   Dali::Radian *argp2 ;
81915   Dali::Radian *argp3 ;
81916
81917   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81918   argp2 = (Dali::Radian *)jarg2;
81919   if (!argp2) {
81920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81921     return ;
81922   }
81923   arg2 = *argp2;
81924   argp3 = (Dali::Radian *)jarg3;
81925   if (!argp3) {
81926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81927     return ;
81928   }
81929   arg3 = *argp3;
81930   {
81931     try {
81932       (arg1)->SetScrollingDirection(arg2,arg3);
81933     } catch (std::out_of_range& e) {
81934       {
81935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81936       };
81937     } catch (std::exception& e) {
81938       {
81939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81940       };
81941     } catch (Dali::DaliException e) {
81942       {
81943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81944       };
81945     } catch (...) {
81946       {
81947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81948       };
81949     }
81950   }
81951
81952 }
81953
81954
81955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81956   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81957   Dali::Radian arg2 ;
81958   Dali::Radian *argp2 ;
81959
81960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81961   argp2 = (Dali::Radian *)jarg2;
81962   if (!argp2) {
81963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81964     return ;
81965   }
81966   arg2 = *argp2;
81967   {
81968     try {
81969       (arg1)->SetScrollingDirection(arg2);
81970     } catch (std::out_of_range& e) {
81971       {
81972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81973       };
81974     } catch (std::exception& e) {
81975       {
81976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81977       };
81978     } catch (Dali::DaliException e) {
81979       {
81980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81981       };
81982     } catch (...) {
81983       {
81984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81985       };
81986     }
81987   }
81988
81989 }
81990
81991
81992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81994   Dali::Radian arg2 ;
81995   Dali::Radian *argp2 ;
81996
81997   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81998   argp2 = (Dali::Radian *)jarg2;
81999   if (!argp2) {
82000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82001     return ;
82002   }
82003   arg2 = *argp2;
82004   {
82005     try {
82006       (arg1)->RemoveScrollingDirection(arg2);
82007     } catch (std::out_of_range& e) {
82008       {
82009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82010       };
82011     } catch (std::exception& e) {
82012       {
82013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82014       };
82015     } catch (Dali::DaliException e) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82018       };
82019     } catch (...) {
82020       {
82021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82022       };
82023     }
82024   }
82025
82026 }
82027
82028
82029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82030   void * jresult ;
82031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82032   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82033
82034   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82035   {
82036     try {
82037       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82038     } catch (std::out_of_range& e) {
82039       {
82040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82041       };
82042     } catch (std::exception& e) {
82043       {
82044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82045       };
82046     } catch (Dali::DaliException e) {
82047       {
82048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82049       };
82050     } catch (...) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82053       };
82054     }
82055   }
82056
82057   jresult = (void *)result;
82058   return jresult;
82059 }
82060
82061
82062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82063   int jresult ;
82064   int result;
82065
82066   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82067   jresult = (int)result;
82068   return jresult;
82069 }
82070
82071
82072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82073   int jresult ;
82074   int result;
82075
82076   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82077   jresult = (int)result;
82078   return jresult;
82079 }
82080
82081
82082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82083   int jresult ;
82084   int result;
82085
82086   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82087   jresult = (int)result;
82088   return jresult;
82089 }
82090
82091
82092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82093   int jresult ;
82094   int result;
82095
82096   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82097   jresult = (int)result;
82098   return jresult;
82099 }
82100
82101
82102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82103   int jresult ;
82104   int result;
82105
82106   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82107   jresult = (int)result;
82108   return jresult;
82109 }
82110
82111
82112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82113   void * jresult ;
82114   Dali::Toolkit::TableView::Property *result = 0 ;
82115
82116   {
82117     try {
82118       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82119     } catch (std::out_of_range& e) {
82120       {
82121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82122       };
82123     } catch (std::exception& e) {
82124       {
82125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82126       };
82127     } catch (Dali::DaliException e) {
82128       {
82129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82130       };
82131     } catch (...) {
82132       {
82133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82134       };
82135     }
82136   }
82137
82138   jresult = (void *)result;
82139   return jresult;
82140 }
82141
82142
82143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82144   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82145
82146   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82147   {
82148     try {
82149       delete arg1;
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82165       };
82166     }
82167   }
82168
82169 }
82170
82171
82172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82173   int jresult ;
82174   int result;
82175
82176   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82177   jresult = (int)result;
82178   return jresult;
82179 }
82180
82181
82182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82183   int jresult ;
82184   int result;
82185
82186   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82187   jresult = (int)result;
82188   return jresult;
82189 }
82190
82191
82192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82193   int jresult ;
82194   int result;
82195
82196   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82197   jresult = (int)result;
82198   return jresult;
82199 }
82200
82201
82202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82203   int jresult ;
82204   int result;
82205
82206   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82207   jresult = (int)result;
82208   return jresult;
82209 }
82210
82211
82212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82213   int jresult ;
82214   int result;
82215
82216   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82217   jresult = (int)result;
82218   return jresult;
82219 }
82220
82221
82222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82223   void * jresult ;
82224   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82225
82226   {
82227     try {
82228       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82229     } catch (std::out_of_range& e) {
82230       {
82231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82232       };
82233     } catch (std::exception& e) {
82234       {
82235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82236       };
82237     } catch (Dali::DaliException e) {
82238       {
82239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82240       };
82241     } catch (...) {
82242       {
82243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82244       };
82245     }
82246   }
82247
82248   jresult = (void *)result;
82249   return jresult;
82250 }
82251
82252
82253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82254   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82255
82256   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82257   {
82258     try {
82259       delete arg1;
82260     } catch (std::out_of_range& e) {
82261       {
82262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82263       };
82264     } catch (std::exception& e) {
82265       {
82266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82267       };
82268     } catch (Dali::DaliException e) {
82269       {
82270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82271       };
82272     } catch (...) {
82273       {
82274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82275       };
82276     }
82277   }
82278
82279 }
82280
82281
82282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82283   void * jresult ;
82284   unsigned int arg1 ;
82285   unsigned int arg2 ;
82286   unsigned int arg3 ;
82287   unsigned int arg4 ;
82288   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82289
82290   arg1 = (unsigned int)jarg1;
82291   arg2 = (unsigned int)jarg2;
82292   arg3 = (unsigned int)jarg3;
82293   arg4 = (unsigned int)jarg4;
82294   {
82295     try {
82296       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82297     } catch (std::out_of_range& e) {
82298       {
82299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82300       };
82301     } catch (std::exception& e) {
82302       {
82303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82304       };
82305     } catch (Dali::DaliException e) {
82306       {
82307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82308       };
82309     } catch (...) {
82310       {
82311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82312       };
82313     }
82314   }
82315
82316   jresult = (void *)result;
82317   return jresult;
82318 }
82319
82320
82321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82322   void * jresult ;
82323   unsigned int arg1 ;
82324   unsigned int arg2 ;
82325   unsigned int arg3 ;
82326   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82327
82328   arg1 = (unsigned int)jarg1;
82329   arg2 = (unsigned int)jarg2;
82330   arg3 = (unsigned int)jarg3;
82331   {
82332     try {
82333       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82334     } catch (std::out_of_range& e) {
82335       {
82336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82337       };
82338     } catch (std::exception& e) {
82339       {
82340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82341       };
82342     } catch (Dali::DaliException e) {
82343       {
82344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82345       };
82346     } catch (...) {
82347       {
82348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82349       };
82350     }
82351   }
82352
82353   jresult = (void *)result;
82354   return jresult;
82355 }
82356
82357
82358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82359   void * jresult ;
82360   unsigned int arg1 ;
82361   unsigned int arg2 ;
82362   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82363
82364   arg1 = (unsigned int)jarg1;
82365   arg2 = (unsigned int)jarg2;
82366   {
82367     try {
82368       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82369     } catch (std::out_of_range& e) {
82370       {
82371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82372       };
82373     } catch (std::exception& e) {
82374       {
82375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82376       };
82377     } catch (Dali::DaliException e) {
82378       {
82379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82380       };
82381     } catch (...) {
82382       {
82383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82384       };
82385     }
82386   }
82387
82388   jresult = (void *)result;
82389   return jresult;
82390 }
82391
82392
82393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82394   void * jresult ;
82395   unsigned int arg1 ;
82396   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82397
82398   arg1 = (unsigned int)jarg1;
82399   {
82400     try {
82401       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82402     } catch (std::out_of_range& e) {
82403       {
82404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82405       };
82406     } catch (std::exception& e) {
82407       {
82408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82409       };
82410     } catch (Dali::DaliException e) {
82411       {
82412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82413       };
82414     } catch (...) {
82415       {
82416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82417       };
82418     }
82419   }
82420
82421   jresult = (void *)result;
82422   return jresult;
82423 }
82424
82425
82426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82427   void * jresult ;
82428   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82429
82430   {
82431     try {
82432       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82433     } catch (std::out_of_range& e) {
82434       {
82435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82436       };
82437     } catch (std::exception& e) {
82438       {
82439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82440       };
82441     } catch (Dali::DaliException e) {
82442       {
82443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82444       };
82445     } catch (...) {
82446       {
82447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82448       };
82449     }
82450   }
82451
82452   jresult = (void *)result;
82453   return jresult;
82454 }
82455
82456
82457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82458   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82459   unsigned int arg2 ;
82460
82461   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82462   arg2 = (unsigned int)jarg2;
82463   if (arg1) (arg1)->rowIndex = arg2;
82464 }
82465
82466
82467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82468   unsigned int jresult ;
82469   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82470   unsigned int result;
82471
82472   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82473   result = (unsigned int) ((arg1)->rowIndex);
82474   jresult = result;
82475   return jresult;
82476 }
82477
82478
82479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82480   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82481   unsigned int arg2 ;
82482
82483   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82484   arg2 = (unsigned int)jarg2;
82485   if (arg1) (arg1)->columnIndex = arg2;
82486 }
82487
82488
82489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82490   unsigned int jresult ;
82491   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82492   unsigned int result;
82493
82494   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82495   result = (unsigned int) ((arg1)->columnIndex);
82496   jresult = result;
82497   return jresult;
82498 }
82499
82500
82501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82502   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82503   unsigned int arg2 ;
82504
82505   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82506   arg2 = (unsigned int)jarg2;
82507   if (arg1) (arg1)->rowSpan = arg2;
82508 }
82509
82510
82511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82512   unsigned int jresult ;
82513   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82514   unsigned int result;
82515
82516   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82517   result = (unsigned int) ((arg1)->rowSpan);
82518   jresult = result;
82519   return jresult;
82520 }
82521
82522
82523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82524   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82525   unsigned int arg2 ;
82526
82527   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82528   arg2 = (unsigned int)jarg2;
82529   if (arg1) (arg1)->columnSpan = arg2;
82530 }
82531
82532
82533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82534   unsigned int jresult ;
82535   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82536   unsigned int result;
82537
82538   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82539   result = (unsigned int) ((arg1)->columnSpan);
82540   jresult = result;
82541   return jresult;
82542 }
82543
82544
82545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82546   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82547
82548   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82549   {
82550     try {
82551       delete arg1;
82552     } catch (std::out_of_range& e) {
82553       {
82554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82555       };
82556     } catch (std::exception& e) {
82557       {
82558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82559       };
82560     } catch (Dali::DaliException e) {
82561       {
82562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82563       };
82564     } catch (...) {
82565       {
82566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82567       };
82568     }
82569   }
82570
82571 }
82572
82573
82574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82575   void * jresult ;
82576   Dali::Toolkit::TableView *result = 0 ;
82577
82578   {
82579     try {
82580       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82581     } catch (std::out_of_range& e) {
82582       {
82583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82584       };
82585     } catch (std::exception& e) {
82586       {
82587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82588       };
82589     } catch (Dali::DaliException e) {
82590       {
82591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82592       };
82593     } catch (...) {
82594       {
82595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82596       };
82597     }
82598   }
82599
82600   jresult = (void *)result;
82601   return jresult;
82602 }
82603
82604
82605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82606   void * jresult ;
82607   Dali::Toolkit::TableView *arg1 = 0 ;
82608   Dali::Toolkit::TableView *result = 0 ;
82609
82610   arg1 = (Dali::Toolkit::TableView *)jarg1;
82611   if (!arg1) {
82612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82613     return 0;
82614   }
82615   {
82616     try {
82617       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
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_TableView_Assign(void * jarg1, void * jarg2) {
82643   void * jresult ;
82644   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82645   Dali::Toolkit::TableView *arg2 = 0 ;
82646   Dali::Toolkit::TableView *result = 0 ;
82647
82648   arg1 = (Dali::Toolkit::TableView *)jarg1;
82649   arg2 = (Dali::Toolkit::TableView *)jarg2;
82650   if (!arg2) {
82651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82652     return 0;
82653   }
82654   {
82655     try {
82656       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82657     } catch (std::out_of_range& e) {
82658       {
82659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82660       };
82661     } catch (std::exception& e) {
82662       {
82663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82664       };
82665     } catch (Dali::DaliException e) {
82666       {
82667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82668       };
82669     } catch (...) {
82670       {
82671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82672       };
82673     }
82674   }
82675
82676   jresult = (void *)result;
82677   return jresult;
82678 }
82679
82680
82681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82682   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82683
82684   arg1 = (Dali::Toolkit::TableView *)jarg1;
82685   {
82686     try {
82687       delete arg1;
82688     } catch (std::out_of_range& e) {
82689       {
82690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82691       };
82692     } catch (std::exception& e) {
82693       {
82694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82695       };
82696     } catch (Dali::DaliException e) {
82697       {
82698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82699       };
82700     } catch (...) {
82701       {
82702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82703       };
82704     }
82705   }
82706
82707 }
82708
82709
82710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82711   void * jresult ;
82712   unsigned int arg1 ;
82713   unsigned int arg2 ;
82714   Dali::Toolkit::TableView result;
82715
82716   arg1 = (unsigned int)jarg1;
82717   arg2 = (unsigned int)jarg2;
82718   {
82719     try {
82720       result = Dali::Toolkit::TableView::New(arg1,arg2);
82721     } catch (std::out_of_range& e) {
82722       {
82723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82724       };
82725     } catch (std::exception& e) {
82726       {
82727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82728       };
82729     } catch (Dali::DaliException e) {
82730       {
82731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82732       };
82733     } catch (...) {
82734       {
82735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82736       };
82737     }
82738   }
82739
82740   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82741   return jresult;
82742 }
82743
82744
82745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82746   void * jresult ;
82747   Dali::BaseHandle arg1 ;
82748   Dali::BaseHandle *argp1 ;
82749   Dali::Toolkit::TableView result;
82750
82751   argp1 = (Dali::BaseHandle *)jarg1;
82752   if (!argp1) {
82753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82754     return 0;
82755   }
82756   arg1 = *argp1;
82757   {
82758     try {
82759       result = Dali::Toolkit::TableView::DownCast(arg1);
82760     } catch (std::out_of_range& e) {
82761       {
82762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82763       };
82764     } catch (std::exception& e) {
82765       {
82766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82767       };
82768     } catch (Dali::DaliException e) {
82769       {
82770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82771       };
82772     } catch (...) {
82773       {
82774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82775       };
82776     }
82777   }
82778
82779   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82780   return jresult;
82781 }
82782
82783
82784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82785   unsigned int jresult ;
82786   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82787   Dali::Actor arg2 ;
82788   Dali::Toolkit::TableView::CellPosition arg3 ;
82789   Dali::Actor *argp2 ;
82790   Dali::Toolkit::TableView::CellPosition *argp3 ;
82791   bool result;
82792
82793   arg1 = (Dali::Toolkit::TableView *)jarg1;
82794   argp2 = (Dali::Actor *)jarg2;
82795   if (!argp2) {
82796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82797     return 0;
82798   }
82799   arg2 = *argp2;
82800   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82801   if (!argp3) {
82802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82803     return 0;
82804   }
82805   arg3 = *argp3;
82806   {
82807     try {
82808       result = (bool)(arg1)->AddChild(arg2,arg3);
82809     } catch (std::out_of_range& e) {
82810       {
82811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82812       };
82813     } catch (std::exception& e) {
82814       {
82815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82816       };
82817     } catch (Dali::DaliException e) {
82818       {
82819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82820       };
82821     } catch (...) {
82822       {
82823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82824       };
82825     }
82826   }
82827
82828   jresult = result;
82829   return jresult;
82830 }
82831
82832
82833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82834   void * jresult ;
82835   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82836   Dali::Toolkit::TableView::CellPosition arg2 ;
82837   Dali::Toolkit::TableView::CellPosition *argp2 ;
82838   Dali::Actor result;
82839
82840   arg1 = (Dali::Toolkit::TableView *)jarg1;
82841   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82842   if (!argp2) {
82843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82844     return 0;
82845   }
82846   arg2 = *argp2;
82847   {
82848     try {
82849       result = (arg1)->GetChildAt(arg2);
82850     } catch (std::out_of_range& e) {
82851       {
82852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82853       };
82854     } catch (std::exception& e) {
82855       {
82856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82857       };
82858     } catch (Dali::DaliException e) {
82859       {
82860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82861       };
82862     } catch (...) {
82863       {
82864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82865       };
82866     }
82867   }
82868
82869   jresult = new Dali::Actor((const Dali::Actor &)result);
82870   return jresult;
82871 }
82872
82873
82874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82875   void * jresult ;
82876   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82877   Dali::Toolkit::TableView::CellPosition arg2 ;
82878   Dali::Toolkit::TableView::CellPosition *argp2 ;
82879   Dali::Actor result;
82880
82881   arg1 = (Dali::Toolkit::TableView *)jarg1;
82882   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82883   if (!argp2) {
82884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82885     return 0;
82886   }
82887   arg2 = *argp2;
82888   {
82889     try {
82890       result = (arg1)->RemoveChildAt(arg2);
82891     } catch (std::out_of_range& e) {
82892       {
82893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82894       };
82895     } catch (std::exception& e) {
82896       {
82897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82898       };
82899     } catch (Dali::DaliException e) {
82900       {
82901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82902       };
82903     } catch (...) {
82904       {
82905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82906       };
82907     }
82908   }
82909
82910   jresult = new Dali::Actor((const Dali::Actor &)result);
82911   return jresult;
82912 }
82913
82914
82915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82916   unsigned int jresult ;
82917   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82918   Dali::Actor arg2 ;
82919   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82920   Dali::Actor *argp2 ;
82921   bool result;
82922
82923   arg1 = (Dali::Toolkit::TableView *)jarg1;
82924   argp2 = (Dali::Actor *)jarg2;
82925   if (!argp2) {
82926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82927     return 0;
82928   }
82929   arg2 = *argp2;
82930   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82931   if (!arg3) {
82932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82933     return 0;
82934   }
82935   {
82936     try {
82937       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82938     } catch (std::out_of_range& e) {
82939       {
82940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82941       };
82942     } catch (std::exception& e) {
82943       {
82944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82945       };
82946     } catch (Dali::DaliException e) {
82947       {
82948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82949       };
82950     } catch (...) {
82951       {
82952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82953       };
82954     }
82955   }
82956
82957   jresult = result;
82958   return jresult;
82959 }
82960
82961
82962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82963   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82964   unsigned int arg2 ;
82965
82966   arg1 = (Dali::Toolkit::TableView *)jarg1;
82967   arg2 = (unsigned int)jarg2;
82968   {
82969     try {
82970       (arg1)->InsertRow(arg2);
82971     } catch (std::out_of_range& e) {
82972       {
82973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82974       };
82975     } catch (std::exception& e) {
82976       {
82977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82978       };
82979     } catch (Dali::DaliException e) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82982       };
82983     } catch (...) {
82984       {
82985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82986       };
82987     }
82988   }
82989
82990 }
82991
82992
82993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82994   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82995   unsigned int arg2 ;
82996
82997   arg1 = (Dali::Toolkit::TableView *)jarg1;
82998   arg2 = (unsigned int)jarg2;
82999   {
83000     try {
83001       (arg1)->DeleteRow(arg2);
83002     } catch (std::out_of_range& e) {
83003       {
83004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83005       };
83006     } catch (std::exception& e) {
83007       {
83008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83009       };
83010     } catch (Dali::DaliException e) {
83011       {
83012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83013       };
83014     } catch (...) {
83015       {
83016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83017       };
83018     }
83019   }
83020
83021 }
83022
83023
83024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83025   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83026   unsigned int arg2 ;
83027   std::vector< Dali::Actor > *arg3 = 0 ;
83028
83029   arg1 = (Dali::Toolkit::TableView *)jarg1;
83030   arg2 = (unsigned int)jarg2;
83031   arg3 = (std::vector< Dali::Actor > *)jarg3;
83032   if (!arg3) {
83033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83034     return ;
83035   }
83036   {
83037     try {
83038       (arg1)->DeleteRow(arg2,*arg3);
83039     } catch (std::out_of_range& e) {
83040       {
83041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83042       };
83043     } catch (std::exception& e) {
83044       {
83045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83046       };
83047     } catch (Dali::DaliException e) {
83048       {
83049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83050       };
83051     } catch (...) {
83052       {
83053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83054       };
83055     }
83056   }
83057
83058 }
83059
83060
83061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83062   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83063   unsigned int arg2 ;
83064
83065   arg1 = (Dali::Toolkit::TableView *)jarg1;
83066   arg2 = (unsigned int)jarg2;
83067   {
83068     try {
83069       (arg1)->InsertColumn(arg2);
83070     } catch (std::out_of_range& e) {
83071       {
83072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83073       };
83074     } catch (std::exception& e) {
83075       {
83076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83077       };
83078     } catch (Dali::DaliException e) {
83079       {
83080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83081       };
83082     } catch (...) {
83083       {
83084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83085       };
83086     }
83087   }
83088
83089 }
83090
83091
83092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83093   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83094   unsigned int arg2 ;
83095
83096   arg1 = (Dali::Toolkit::TableView *)jarg1;
83097   arg2 = (unsigned int)jarg2;
83098   {
83099     try {
83100       (arg1)->DeleteColumn(arg2);
83101     } catch (std::out_of_range& e) {
83102       {
83103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83104       };
83105     } catch (std::exception& e) {
83106       {
83107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83108       };
83109     } catch (Dali::DaliException e) {
83110       {
83111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83112       };
83113     } catch (...) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83116       };
83117     }
83118   }
83119
83120 }
83121
83122
83123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83124   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83125   unsigned int arg2 ;
83126   std::vector< Dali::Actor > *arg3 = 0 ;
83127
83128   arg1 = (Dali::Toolkit::TableView *)jarg1;
83129   arg2 = (unsigned int)jarg2;
83130   arg3 = (std::vector< Dali::Actor > *)jarg3;
83131   if (!arg3) {
83132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83133     return ;
83134   }
83135   {
83136     try {
83137       (arg1)->DeleteColumn(arg2,*arg3);
83138     } catch (std::out_of_range& e) {
83139       {
83140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83141       };
83142     } catch (std::exception& e) {
83143       {
83144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83145       };
83146     } catch (Dali::DaliException e) {
83147       {
83148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83149       };
83150     } catch (...) {
83151       {
83152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83153       };
83154     }
83155   }
83156
83157 }
83158
83159
83160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83161   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83162   unsigned int arg2 ;
83163   unsigned int arg3 ;
83164
83165   arg1 = (Dali::Toolkit::TableView *)jarg1;
83166   arg2 = (unsigned int)jarg2;
83167   arg3 = (unsigned int)jarg3;
83168   {
83169     try {
83170       (arg1)->Resize(arg2,arg3);
83171     } catch (std::out_of_range& e) {
83172       {
83173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83174       };
83175     } catch (std::exception& e) {
83176       {
83177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83178       };
83179     } catch (Dali::DaliException e) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83182       };
83183     } catch (...) {
83184       {
83185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83186       };
83187     }
83188   }
83189
83190 }
83191
83192
83193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83194   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83195   unsigned int arg2 ;
83196   unsigned int arg3 ;
83197   std::vector< Dali::Actor > *arg4 = 0 ;
83198
83199   arg1 = (Dali::Toolkit::TableView *)jarg1;
83200   arg2 = (unsigned int)jarg2;
83201   arg3 = (unsigned int)jarg3;
83202   arg4 = (std::vector< Dali::Actor > *)jarg4;
83203   if (!arg4) {
83204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83205     return ;
83206   }
83207   {
83208     try {
83209       (arg1)->Resize(arg2,arg3,*arg4);
83210     } catch (std::out_of_range& e) {
83211       {
83212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83213       };
83214     } catch (std::exception& e) {
83215       {
83216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83217       };
83218     } catch (Dali::DaliException e) {
83219       {
83220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83221       };
83222     } catch (...) {
83223       {
83224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83225       };
83226     }
83227   }
83228
83229 }
83230
83231
83232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83233   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83234   Dali::Size arg2 ;
83235   Dali::Size *argp2 ;
83236
83237   arg1 = (Dali::Toolkit::TableView *)jarg1;
83238   argp2 = (Dali::Size *)jarg2;
83239   if (!argp2) {
83240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83241     return ;
83242   }
83243   arg2 = *argp2;
83244   {
83245     try {
83246       (arg1)->SetCellPadding(arg2);
83247     } catch (std::out_of_range& e) {
83248       {
83249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83250       };
83251     } catch (std::exception& e) {
83252       {
83253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83254       };
83255     } catch (Dali::DaliException e) {
83256       {
83257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83258       };
83259     } catch (...) {
83260       {
83261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83262       };
83263     }
83264   }
83265
83266 }
83267
83268
83269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83270   void * jresult ;
83271   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83272   Dali::Size result;
83273
83274   arg1 = (Dali::Toolkit::TableView *)jarg1;
83275   {
83276     try {
83277       result = (arg1)->GetCellPadding();
83278     } catch (std::out_of_range& e) {
83279       {
83280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83281       };
83282     } catch (std::exception& e) {
83283       {
83284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83285       };
83286     } catch (Dali::DaliException e) {
83287       {
83288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83289       };
83290     } catch (...) {
83291       {
83292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83293       };
83294     }
83295   }
83296
83297   jresult = new Dali::Size((const Dali::Size &)result);
83298   return jresult;
83299 }
83300
83301
83302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83303   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83304   unsigned int arg2 ;
83305
83306   arg1 = (Dali::Toolkit::TableView *)jarg1;
83307   arg2 = (unsigned int)jarg2;
83308   {
83309     try {
83310       (arg1)->SetFitHeight(arg2);
83311     } catch (std::out_of_range& e) {
83312       {
83313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83314       };
83315     } catch (std::exception& e) {
83316       {
83317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83318       };
83319     } catch (Dali::DaliException e) {
83320       {
83321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83322       };
83323     } catch (...) {
83324       {
83325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83326       };
83327     }
83328   }
83329
83330 }
83331
83332
83333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83334   unsigned int jresult ;
83335   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83336   unsigned int arg2 ;
83337   bool result;
83338
83339   arg1 = (Dali::Toolkit::TableView *)jarg1;
83340   arg2 = (unsigned int)jarg2;
83341   {
83342     try {
83343       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83344     } catch (std::out_of_range& e) {
83345       {
83346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83347       };
83348     } catch (std::exception& e) {
83349       {
83350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83351       };
83352     } catch (Dali::DaliException e) {
83353       {
83354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83355       };
83356     } catch (...) {
83357       {
83358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83359       };
83360     }
83361   }
83362
83363   jresult = result;
83364   return jresult;
83365 }
83366
83367
83368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83369   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83370   unsigned int arg2 ;
83371
83372   arg1 = (Dali::Toolkit::TableView *)jarg1;
83373   arg2 = (unsigned int)jarg2;
83374   {
83375     try {
83376       (arg1)->SetFitWidth(arg2);
83377     } catch (std::out_of_range& e) {
83378       {
83379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83380       };
83381     } catch (std::exception& e) {
83382       {
83383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83384       };
83385     } catch (Dali::DaliException e) {
83386       {
83387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83388       };
83389     } catch (...) {
83390       {
83391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83392       };
83393     }
83394   }
83395
83396 }
83397
83398
83399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83400   unsigned int jresult ;
83401   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83402   unsigned int arg2 ;
83403   bool result;
83404
83405   arg1 = (Dali::Toolkit::TableView *)jarg1;
83406   arg2 = (unsigned int)jarg2;
83407   {
83408     try {
83409       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83410     } catch (std::out_of_range& e) {
83411       {
83412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83413       };
83414     } catch (std::exception& e) {
83415       {
83416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83417       };
83418     } catch (Dali::DaliException e) {
83419       {
83420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83421       };
83422     } catch (...) {
83423       {
83424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83425       };
83426     }
83427   }
83428
83429   jresult = result;
83430   return jresult;
83431 }
83432
83433
83434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83435   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83436   unsigned int arg2 ;
83437   float arg3 ;
83438
83439   arg1 = (Dali::Toolkit::TableView *)jarg1;
83440   arg2 = (unsigned int)jarg2;
83441   arg3 = (float)jarg3;
83442   {
83443     try {
83444       (arg1)->SetFixedHeight(arg2,arg3);
83445     } catch (std::out_of_range& e) {
83446       {
83447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83448       };
83449     } catch (std::exception& e) {
83450       {
83451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83452       };
83453     } catch (Dali::DaliException e) {
83454       {
83455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83456       };
83457     } catch (...) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83460       };
83461     }
83462   }
83463
83464 }
83465
83466
83467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83468   float jresult ;
83469   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83470   unsigned int arg2 ;
83471   float result;
83472
83473   arg1 = (Dali::Toolkit::TableView *)jarg1;
83474   arg2 = (unsigned int)jarg2;
83475   {
83476     try {
83477       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83478     } catch (std::out_of_range& e) {
83479       {
83480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83481       };
83482     } catch (std::exception& e) {
83483       {
83484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83485       };
83486     } catch (Dali::DaliException e) {
83487       {
83488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83489       };
83490     } catch (...) {
83491       {
83492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83493       };
83494     }
83495   }
83496
83497   jresult = result;
83498   return jresult;
83499 }
83500
83501
83502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83503   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83504   unsigned int arg2 ;
83505   float arg3 ;
83506
83507   arg1 = (Dali::Toolkit::TableView *)jarg1;
83508   arg2 = (unsigned int)jarg2;
83509   arg3 = (float)jarg3;
83510   {
83511     try {
83512       (arg1)->SetRelativeHeight(arg2,arg3);
83513     } catch (std::out_of_range& e) {
83514       {
83515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83516       };
83517     } catch (std::exception& e) {
83518       {
83519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83520       };
83521     } catch (Dali::DaliException e) {
83522       {
83523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83524       };
83525     } catch (...) {
83526       {
83527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83528       };
83529     }
83530   }
83531
83532 }
83533
83534
83535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83536   float jresult ;
83537   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83538   unsigned int arg2 ;
83539   float result;
83540
83541   arg1 = (Dali::Toolkit::TableView *)jarg1;
83542   arg2 = (unsigned int)jarg2;
83543   {
83544     try {
83545       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83546     } catch (std::out_of_range& e) {
83547       {
83548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83549       };
83550     } catch (std::exception& e) {
83551       {
83552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83553       };
83554     } catch (Dali::DaliException e) {
83555       {
83556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83557       };
83558     } catch (...) {
83559       {
83560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83561       };
83562     }
83563   }
83564
83565   jresult = result;
83566   return jresult;
83567 }
83568
83569
83570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83571   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83572   unsigned int arg2 ;
83573   float arg3 ;
83574
83575   arg1 = (Dali::Toolkit::TableView *)jarg1;
83576   arg2 = (unsigned int)jarg2;
83577   arg3 = (float)jarg3;
83578   {
83579     try {
83580       (arg1)->SetFixedWidth(arg2,arg3);
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83596       };
83597     }
83598   }
83599
83600 }
83601
83602
83603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83604   float jresult ;
83605   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83606   unsigned int arg2 ;
83607   float result;
83608
83609   arg1 = (Dali::Toolkit::TableView *)jarg1;
83610   arg2 = (unsigned int)jarg2;
83611   {
83612     try {
83613       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83614     } catch (std::out_of_range& e) {
83615       {
83616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83617       };
83618     } catch (std::exception& e) {
83619       {
83620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83621       };
83622     } catch (Dali::DaliException e) {
83623       {
83624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83625       };
83626     } catch (...) {
83627       {
83628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83629       };
83630     }
83631   }
83632
83633   jresult = result;
83634   return jresult;
83635 }
83636
83637
83638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83639   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83640   unsigned int arg2 ;
83641   float arg3 ;
83642
83643   arg1 = (Dali::Toolkit::TableView *)jarg1;
83644   arg2 = (unsigned int)jarg2;
83645   arg3 = (float)jarg3;
83646   {
83647     try {
83648       (arg1)->SetRelativeWidth(arg2,arg3);
83649     } catch (std::out_of_range& e) {
83650       {
83651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83652       };
83653     } catch (std::exception& e) {
83654       {
83655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83656       };
83657     } catch (Dali::DaliException e) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83660       };
83661     } catch (...) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83664       };
83665     }
83666   }
83667
83668 }
83669
83670
83671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83672   float jresult ;
83673   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83674   unsigned int arg2 ;
83675   float result;
83676
83677   arg1 = (Dali::Toolkit::TableView *)jarg1;
83678   arg2 = (unsigned int)jarg2;
83679   {
83680     try {
83681       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83682     } catch (std::out_of_range& e) {
83683       {
83684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83685       };
83686     } catch (std::exception& e) {
83687       {
83688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83689       };
83690     } catch (Dali::DaliException e) {
83691       {
83692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83693       };
83694     } catch (...) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83697       };
83698     }
83699   }
83700
83701   jresult = result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83707   unsigned int jresult ;
83708   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83709   unsigned int result;
83710
83711   arg1 = (Dali::Toolkit::TableView *)jarg1;
83712   {
83713     try {
83714       result = (unsigned int)(arg1)->GetRows();
83715     } catch (std::out_of_range& e) {
83716       {
83717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83718       };
83719     } catch (std::exception& e) {
83720       {
83721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83722       };
83723     } catch (Dali::DaliException e) {
83724       {
83725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83726       };
83727     } catch (...) {
83728       {
83729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83730       };
83731     }
83732   }
83733
83734   jresult = result;
83735   return jresult;
83736 }
83737
83738
83739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83740   unsigned int jresult ;
83741   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83742   unsigned int result;
83743
83744   arg1 = (Dali::Toolkit::TableView *)jarg1;
83745   {
83746     try {
83747       result = (unsigned int)(arg1)->GetColumns();
83748     } catch (std::out_of_range& e) {
83749       {
83750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83751       };
83752     } catch (std::exception& e) {
83753       {
83754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83755       };
83756     } catch (Dali::DaliException e) {
83757       {
83758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83759       };
83760     } catch (...) {
83761       {
83762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83763       };
83764     }
83765   }
83766
83767   jresult = result;
83768   return jresult;
83769 }
83770
83771
83772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83773   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83774   Dali::Toolkit::TableView::CellPosition arg2 ;
83775   Dali::HorizontalAlignment::Type arg3 ;
83776   Dali::VerticalAlignment::Type arg4 ;
83777   Dali::Toolkit::TableView::CellPosition *argp2 ;
83778
83779   arg1 = (Dali::Toolkit::TableView *)jarg1;
83780   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83781   if (!argp2) {
83782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83783     return ;
83784   }
83785   arg2 = *argp2;
83786   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83787   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83788   {
83789     try {
83790       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83791     } catch (std::out_of_range& e) {
83792       {
83793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83794       };
83795     } catch (std::exception& e) {
83796       {
83797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83798       };
83799     } catch (Dali::DaliException e) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83806       };
83807     }
83808   }
83809
83810 }
83811
83812
83813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83814   unsigned int jresult ;
83815   unsigned int result;
83816
83817   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83818   jresult = result;
83819   return jresult;
83820 }
83821
83822
83823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83824   int jresult ;
83825   int result;
83826
83827   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83828   jresult = (int)result;
83829   return jresult;
83830 }
83831
83832
83833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83834   int jresult ;
83835   int result;
83836
83837   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83838   jresult = (int)result;
83839   return jresult;
83840 }
83841
83842
83843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83844   int jresult ;
83845   int result;
83846
83847   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83848   jresult = (int)result;
83849   return jresult;
83850 }
83851
83852
83853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83854   int jresult ;
83855   int result;
83856
83857   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83858   jresult = (int)result;
83859   return jresult;
83860 }
83861
83862
83863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83864   int jresult ;
83865   int result;
83866
83867   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83868   jresult = (int)result;
83869   return jresult;
83870 }
83871
83872
83873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83874   int jresult ;
83875   int result;
83876
83877   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83878   jresult = (int)result;
83879   return jresult;
83880 }
83881
83882
83883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83884   int jresult ;
83885   int result;
83886
83887   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83888   jresult = (int)result;
83889   return jresult;
83890 }
83891
83892
83893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83894   int jresult ;
83895   int result;
83896
83897   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83898   jresult = (int)result;
83899   return jresult;
83900 }
83901
83902
83903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83904   int jresult ;
83905   int result;
83906
83907   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83908   jresult = (int)result;
83909   return jresult;
83910 }
83911
83912
83913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83914   int jresult ;
83915   int result;
83916
83917   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83918   jresult = (int)result;
83919   return jresult;
83920 }
83921
83922
83923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83924   int jresult ;
83925   int result;
83926
83927   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83928   jresult = (int)result;
83929   return jresult;
83930 }
83931
83932
83933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83934   int jresult ;
83935   int result;
83936
83937   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83938   jresult = (int)result;
83939   return jresult;
83940 }
83941
83942
83943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83944   int jresult ;
83945   int result;
83946
83947   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83948   jresult = (int)result;
83949   return jresult;
83950 }
83951
83952
83953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83954   int jresult ;
83955   int result;
83956
83957   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83958   jresult = (int)result;
83959   return jresult;
83960 }
83961
83962
83963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83964   int jresult ;
83965   int result;
83966
83967   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83968   jresult = (int)result;
83969   return jresult;
83970 }
83971
83972
83973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83974   int jresult ;
83975   int result;
83976
83977   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83978   jresult = (int)result;
83979   return jresult;
83980 }
83981
83982
83983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83984   int jresult ;
83985   int result;
83986
83987   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83988   jresult = (int)result;
83989   return jresult;
83990 }
83991
83992
83993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83994   int jresult ;
83995   int result;
83996
83997   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83998   jresult = (int)result;
83999   return jresult;
84000 }
84001
84002
84003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84004   int jresult ;
84005   int result;
84006
84007   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84008   jresult = (int)result;
84009   return jresult;
84010 }
84011
84012
84013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84014   void * jresult ;
84015   Dali::Toolkit::TextLabel::Property *result = 0 ;
84016
84017   {
84018     try {
84019       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84020     } catch (std::out_of_range& e) {
84021       {
84022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84023       };
84024     } catch (std::exception& e) {
84025       {
84026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84027       };
84028     } catch (Dali::DaliException e) {
84029       {
84030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84031       };
84032     } catch (...) {
84033       {
84034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84035       };
84036     }
84037   }
84038
84039   jresult = (void *)result;
84040   return jresult;
84041 }
84042
84043
84044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84045   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84046
84047   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84048   {
84049     try {
84050       delete arg1;
84051     } catch (std::out_of_range& e) {
84052       {
84053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84054       };
84055     } catch (std::exception& e) {
84056       {
84057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84058       };
84059     } catch (Dali::DaliException e) {
84060       {
84061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84062       };
84063     } catch (...) {
84064       {
84065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84066       };
84067     }
84068   }
84069
84070 }
84071
84072
84073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84074   void * jresult ;
84075   Dali::Toolkit::TextLabel result;
84076
84077   {
84078     try {
84079       result = Dali::Toolkit::TextLabel::New();
84080     } catch (std::out_of_range& e) {
84081       {
84082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84083       };
84084     } catch (std::exception& e) {
84085       {
84086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84087       };
84088     } catch (Dali::DaliException e) {
84089       {
84090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84091       };
84092     } catch (...) {
84093       {
84094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84095       };
84096     }
84097   }
84098
84099   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84100   return jresult;
84101 }
84102
84103
84104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84105   void * jresult ;
84106   std::string *arg1 = 0 ;
84107   Dali::Toolkit::TextLabel result;
84108
84109   if (!jarg1) {
84110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84111     return 0;
84112   }
84113   std::string arg1_str(jarg1);
84114   arg1 = &arg1_str;
84115   {
84116     try {
84117       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84118     } catch (std::out_of_range& e) {
84119       {
84120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84121       };
84122     } catch (std::exception& e) {
84123       {
84124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84125       };
84126     } catch (Dali::DaliException e) {
84127       {
84128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84129       };
84130     } catch (...) {
84131       {
84132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84133       };
84134     }
84135   }
84136
84137   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84138
84139   //argout typemap for const std::string&
84140
84141   return jresult;
84142 }
84143
84144
84145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84146   void * jresult ;
84147   Dali::Toolkit::TextLabel *result = 0 ;
84148
84149   {
84150     try {
84151       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84152     } catch (std::out_of_range& e) {
84153       {
84154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84155       };
84156     } catch (std::exception& e) {
84157       {
84158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84159       };
84160     } catch (Dali::DaliException e) {
84161       {
84162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84163       };
84164     } catch (...) {
84165       {
84166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84167       };
84168     }
84169   }
84170
84171   jresult = (void *)result;
84172   return jresult;
84173 }
84174
84175
84176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84177   void * jresult ;
84178   Dali::Toolkit::TextLabel *arg1 = 0 ;
84179   Dali::Toolkit::TextLabel *result = 0 ;
84180
84181   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84182   if (!arg1) {
84183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84184     return 0;
84185   }
84186   {
84187     try {
84188       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84189     } catch (std::out_of_range& e) {
84190       {
84191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84192       };
84193     } catch (std::exception& e) {
84194       {
84195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84196       };
84197     } catch (Dali::DaliException e) {
84198       {
84199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84200       };
84201     } catch (...) {
84202       {
84203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84204       };
84205     }
84206   }
84207
84208   jresult = (void *)result;
84209   return jresult;
84210 }
84211
84212
84213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84214   void * jresult ;
84215   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84216   Dali::Toolkit::TextLabel *arg2 = 0 ;
84217   Dali::Toolkit::TextLabel *result = 0 ;
84218
84219   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84220   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84221   if (!arg2) {
84222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84223     return 0;
84224   }
84225   {
84226     try {
84227       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84228     } catch (std::out_of_range& e) {
84229       {
84230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84231       };
84232     } catch (std::exception& e) {
84233       {
84234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84235       };
84236     } catch (Dali::DaliException e) {
84237       {
84238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84239       };
84240     } catch (...) {
84241       {
84242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84243       };
84244     }
84245   }
84246
84247   jresult = (void *)result;
84248   return jresult;
84249 }
84250
84251
84252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84253   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84254
84255   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84256   {
84257     try {
84258       delete arg1;
84259     } catch (std::out_of_range& e) {
84260       {
84261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84262       };
84263     } catch (std::exception& e) {
84264       {
84265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84266       };
84267     } catch (Dali::DaliException e) {
84268       {
84269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84270       };
84271     } catch (...) {
84272       {
84273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84274       };
84275     }
84276   }
84277
84278 }
84279
84280
84281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84282   void * jresult ;
84283   Dali::BaseHandle arg1 ;
84284   Dali::BaseHandle *argp1 ;
84285   Dali::Toolkit::TextLabel result;
84286
84287   argp1 = (Dali::BaseHandle *)jarg1;
84288   if (!argp1) {
84289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84290     return 0;
84291   }
84292   arg1 = *argp1;
84293   {
84294     try {
84295       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84296     } catch (std::out_of_range& e) {
84297       {
84298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84299       };
84300     } catch (std::exception& e) {
84301       {
84302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84303       };
84304     } catch (Dali::DaliException e) {
84305       {
84306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84307       };
84308     } catch (...) {
84309       {
84310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84311       };
84312     }
84313   }
84314
84315   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84316   return jresult;
84317 }
84318
84319
84320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84321   void * jresult ;
84322   Dali::Toolkit::AccessibilityManager *result = 0 ;
84323
84324   {
84325     try {
84326       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84327     } catch (std::out_of_range& e) {
84328       {
84329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84330       };
84331     } catch (std::exception& e) {
84332       {
84333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84334       };
84335     } catch (Dali::DaliException e) {
84336       {
84337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84338       };
84339     } catch (...) {
84340       {
84341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84342       };
84343     }
84344   }
84345
84346   jresult = (void *)result;
84347   return jresult;
84348 }
84349
84350
84351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84352   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84353
84354   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84355   {
84356     try {
84357       delete arg1;
84358     } catch (std::out_of_range& e) {
84359       {
84360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84361       };
84362     } catch (std::exception& e) {
84363       {
84364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84365       };
84366     } catch (Dali::DaliException e) {
84367       {
84368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84369       };
84370     } catch (...) {
84371       {
84372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84373       };
84374     }
84375   }
84376
84377 }
84378
84379
84380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84381   void * jresult ;
84382   Dali::Toolkit::AccessibilityManager result;
84383
84384   {
84385     try {
84386       result = Dali::Toolkit::AccessibilityManager::Get();
84387     } catch (std::out_of_range& e) {
84388       {
84389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84390       };
84391     } catch (std::exception& e) {
84392       {
84393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84394       };
84395     } catch (Dali::DaliException e) {
84396       {
84397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84398       };
84399     } catch (...) {
84400       {
84401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84402       };
84403     }
84404   }
84405
84406   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84407   return jresult;
84408 }
84409
84410
84411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84413   Dali::Actor arg2 ;
84414   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84415   std::string *arg4 = 0 ;
84416   Dali::Actor *argp2 ;
84417
84418   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84419   argp2 = (Dali::Actor *)jarg2;
84420   if (!argp2) {
84421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84422     return ;
84423   }
84424   arg2 = *argp2;
84425   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84426   if (!jarg4) {
84427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84428     return ;
84429   }
84430   std::string arg4_str(jarg4);
84431   arg4 = &arg4_str;
84432   {
84433     try {
84434       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84442       };
84443     } catch (Dali::DaliException e) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84446       };
84447     } catch (...) {
84448       {
84449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84450       };
84451     }
84452   }
84453
84454
84455   //argout typemap for const std::string&
84456
84457 }
84458
84459
84460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84461   char * jresult ;
84462   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84463   Dali::Actor arg2 ;
84464   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84465   Dali::Actor *argp2 ;
84466   std::string result;
84467
84468   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84469   argp2 = (Dali::Actor *)jarg2;
84470   if (!argp2) {
84471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84472     return 0;
84473   }
84474   arg2 = *argp2;
84475   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84476   {
84477     try {
84478       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84479     } catch (std::out_of_range& e) {
84480       {
84481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84482       };
84483     } catch (std::exception& e) {
84484       {
84485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84486       };
84487     } catch (Dali::DaliException e) {
84488       {
84489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84490       };
84491     } catch (...) {
84492       {
84493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84494       };
84495     }
84496   }
84497
84498   jresult = SWIG_csharp_string_callback((&result)->c_str());
84499   return jresult;
84500 }
84501
84502
84503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84504   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84505   Dali::Actor arg2 ;
84506   unsigned int arg3 ;
84507   Dali::Actor *argp2 ;
84508
84509   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84510   argp2 = (Dali::Actor *)jarg2;
84511   if (!argp2) {
84512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84513     return ;
84514   }
84515   arg2 = *argp2;
84516   arg3 = (unsigned int)jarg3;
84517   {
84518     try {
84519       (arg1)->SetFocusOrder(arg2,arg3);
84520     } catch (std::out_of_range& e) {
84521       {
84522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84523       };
84524     } catch (std::exception& e) {
84525       {
84526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84527       };
84528     } catch (Dali::DaliException e) {
84529       {
84530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84531       };
84532     } catch (...) {
84533       {
84534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84535       };
84536     }
84537   }
84538
84539 }
84540
84541
84542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84543   unsigned int jresult ;
84544   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84545   Dali::Actor arg2 ;
84546   Dali::Actor *argp2 ;
84547   unsigned int result;
84548
84549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84550   argp2 = (Dali::Actor *)jarg2;
84551   if (!argp2) {
84552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84553     return 0;
84554   }
84555   arg2 = *argp2;
84556   {
84557     try {
84558       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84559     } catch (std::out_of_range& e) {
84560       {
84561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84562       };
84563     } catch (std::exception& e) {
84564       {
84565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84566       };
84567     } catch (Dali::DaliException e) {
84568       {
84569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84570       };
84571     } catch (...) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84574       };
84575     }
84576   }
84577
84578   jresult = result;
84579   return jresult;
84580 }
84581
84582
84583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84584   unsigned int jresult ;
84585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84586   unsigned int result;
84587
84588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84589   {
84590     try {
84591       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84592     } catch (std::out_of_range& e) {
84593       {
84594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84595       };
84596     } catch (std::exception& e) {
84597       {
84598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84599       };
84600     } catch (Dali::DaliException e) {
84601       {
84602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84603       };
84604     } catch (...) {
84605       {
84606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84607       };
84608     }
84609   }
84610
84611   jresult = result;
84612   return jresult;
84613 }
84614
84615
84616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84617   void * jresult ;
84618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84619   unsigned int arg2 ;
84620   Dali::Actor result;
84621
84622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84623   arg2 = (unsigned int)jarg2;
84624   {
84625     try {
84626       result = (arg1)->GetActorByFocusOrder(arg2);
84627     } catch (std::out_of_range& e) {
84628       {
84629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84630       };
84631     } catch (std::exception& e) {
84632       {
84633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84634       };
84635     } catch (Dali::DaliException e) {
84636       {
84637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84638       };
84639     } catch (...) {
84640       {
84641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84642       };
84643     }
84644   }
84645
84646   jresult = new Dali::Actor((const Dali::Actor &)result);
84647   return jresult;
84648 }
84649
84650
84651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84652   unsigned int jresult ;
84653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84654   Dali::Actor arg2 ;
84655   Dali::Actor *argp2 ;
84656   bool result;
84657
84658   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84659   argp2 = (Dali::Actor *)jarg2;
84660   if (!argp2) {
84661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84662     return 0;
84663   }
84664   arg2 = *argp2;
84665   {
84666     try {
84667       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84668     } catch (std::out_of_range& e) {
84669       {
84670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84671       };
84672     } catch (std::exception& e) {
84673       {
84674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84675       };
84676     } catch (Dali::DaliException e) {
84677       {
84678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84679       };
84680     } catch (...) {
84681       {
84682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84683       };
84684     }
84685   }
84686
84687   jresult = result;
84688   return jresult;
84689 }
84690
84691
84692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84693   void * jresult ;
84694   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84695   Dali::Actor result;
84696
84697   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84698   {
84699     try {
84700       result = (arg1)->GetCurrentFocusActor();
84701     } catch (std::out_of_range& e) {
84702       {
84703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84704       };
84705     } catch (std::exception& e) {
84706       {
84707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84708       };
84709     } catch (Dali::DaliException e) {
84710       {
84711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84712       };
84713     } catch (...) {
84714       {
84715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84716       };
84717     }
84718   }
84719
84720   jresult = new Dali::Actor((const Dali::Actor &)result);
84721   return jresult;
84722 }
84723
84724
84725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84726   void * jresult ;
84727   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84728   Dali::Actor result;
84729
84730   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84731   {
84732     try {
84733       result = (arg1)->GetCurrentFocusGroup();
84734     } catch (std::out_of_range& e) {
84735       {
84736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84737       };
84738     } catch (std::exception& e) {
84739       {
84740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84741       };
84742     } catch (Dali::DaliException e) {
84743       {
84744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84745       };
84746     } catch (...) {
84747       {
84748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84749       };
84750     }
84751   }
84752
84753   jresult = new Dali::Actor((const Dali::Actor &)result);
84754   return jresult;
84755 }
84756
84757
84758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84759   unsigned int jresult ;
84760   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84761   unsigned int result;
84762
84763   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84764   {
84765     try {
84766       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84767     } catch (std::out_of_range& e) {
84768       {
84769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84770       };
84771     } catch (std::exception& e) {
84772       {
84773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84774       };
84775     } catch (Dali::DaliException e) {
84776       {
84777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84778       };
84779     } catch (...) {
84780       {
84781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84782       };
84783     }
84784   }
84785
84786   jresult = result;
84787   return jresult;
84788 }
84789
84790
84791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84792   unsigned int jresult ;
84793   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84794   bool result;
84795
84796   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84797   {
84798     try {
84799       result = (bool)(arg1)->MoveFocusForward();
84800     } catch (std::out_of_range& e) {
84801       {
84802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84803       };
84804     } catch (std::exception& e) {
84805       {
84806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84807       };
84808     } catch (Dali::DaliException e) {
84809       {
84810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84811       };
84812     } catch (...) {
84813       {
84814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84815       };
84816     }
84817   }
84818
84819   jresult = result;
84820   return jresult;
84821 }
84822
84823
84824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84825   unsigned int jresult ;
84826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84827   bool result;
84828
84829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84830   {
84831     try {
84832       result = (bool)(arg1)->MoveFocusBackward();
84833     } catch (std::out_of_range& e) {
84834       {
84835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84836       };
84837     } catch (std::exception& e) {
84838       {
84839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84840       };
84841     } catch (Dali::DaliException e) {
84842       {
84843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84844       };
84845     } catch (...) {
84846       {
84847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84848       };
84849     }
84850   }
84851
84852   jresult = result;
84853   return jresult;
84854 }
84855
84856
84857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84858   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84859
84860   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84861   {
84862     try {
84863       (arg1)->ClearFocus();
84864     } catch (std::out_of_range& e) {
84865       {
84866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84867       };
84868     } catch (std::exception& e) {
84869       {
84870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84871       };
84872     } catch (Dali::DaliException e) {
84873       {
84874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84875       };
84876     } catch (...) {
84877       {
84878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84879       };
84880     }
84881   }
84882
84883 }
84884
84885
84886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84887   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84888
84889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84890   {
84891     try {
84892       (arg1)->Reset();
84893     } catch (std::out_of_range& e) {
84894       {
84895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84896       };
84897     } catch (std::exception& e) {
84898       {
84899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84900       };
84901     } catch (Dali::DaliException e) {
84902       {
84903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84904       };
84905     } catch (...) {
84906       {
84907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84908       };
84909     }
84910   }
84911
84912 }
84913
84914
84915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84916   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84917   Dali::Actor arg2 ;
84918   bool arg3 ;
84919   Dali::Actor *argp2 ;
84920
84921   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84922   argp2 = (Dali::Actor *)jarg2;
84923   if (!argp2) {
84924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84925     return ;
84926   }
84927   arg2 = *argp2;
84928   arg3 = jarg3 ? true : false;
84929   {
84930     try {
84931       (arg1)->SetFocusGroup(arg2,arg3);
84932     } catch (std::out_of_range& e) {
84933       {
84934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84935       };
84936     } catch (std::exception& e) {
84937       {
84938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84939       };
84940     } catch (Dali::DaliException e) {
84941       {
84942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84943       };
84944     } catch (...) {
84945       {
84946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84947       };
84948     }
84949   }
84950
84951 }
84952
84953
84954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84955   unsigned int jresult ;
84956   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84957   Dali::Actor arg2 ;
84958   Dali::Actor *argp2 ;
84959   bool result;
84960
84961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84962   argp2 = (Dali::Actor *)jarg2;
84963   if (!argp2) {
84964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84965     return 0;
84966   }
84967   arg2 = *argp2;
84968   {
84969     try {
84970       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84971     } catch (std::out_of_range& e) {
84972       {
84973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84974       };
84975     } catch (std::exception& e) {
84976       {
84977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84978       };
84979     } catch (Dali::DaliException e) {
84980       {
84981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84982       };
84983     } catch (...) {
84984       {
84985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84986       };
84987     }
84988   }
84989
84990   jresult = result;
84991   return jresult;
84992 }
84993
84994
84995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84996   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84997   bool arg2 ;
84998
84999   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85000   arg2 = jarg2 ? true : false;
85001   {
85002     try {
85003       (arg1)->SetGroupMode(arg2);
85004     } catch (std::out_of_range& e) {
85005       {
85006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85007       };
85008     } catch (std::exception& e) {
85009       {
85010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85011       };
85012     } catch (Dali::DaliException e) {
85013       {
85014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85015       };
85016     } catch (...) {
85017       {
85018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85019       };
85020     }
85021   }
85022
85023 }
85024
85025
85026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85027   unsigned int jresult ;
85028   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85029   bool result;
85030
85031   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85032   {
85033     try {
85034       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85035     } catch (std::out_of_range& e) {
85036       {
85037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85038       };
85039     } catch (std::exception& e) {
85040       {
85041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85042       };
85043     } catch (Dali::DaliException e) {
85044       {
85045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85046       };
85047     } catch (...) {
85048       {
85049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85050       };
85051     }
85052   }
85053
85054   jresult = result;
85055   return jresult;
85056 }
85057
85058
85059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85060   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85061   bool arg2 ;
85062
85063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85064   arg2 = jarg2 ? true : false;
85065   {
85066     try {
85067       (arg1)->SetWrapMode(arg2);
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_GetWrapMode(void * jarg1) {
85091   unsigned int jresult ;
85092   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85093   bool result;
85094
85095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85096   {
85097     try {
85098       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85099     } catch (std::out_of_range& e) {
85100       {
85101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85102       };
85103     } catch (std::exception& e) {
85104       {
85105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85106       };
85107     } catch (Dali::DaliException e) {
85108       {
85109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85110       };
85111     } catch (...) {
85112       {
85113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85114       };
85115     }
85116   }
85117
85118   jresult = result;
85119   return jresult;
85120 }
85121
85122
85123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85124   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85125   Dali::Actor arg2 ;
85126   Dali::Actor *argp2 ;
85127
85128   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85129   argp2 = (Dali::Actor *)jarg2;
85130   if (!argp2) {
85131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85132     return ;
85133   }
85134   arg2 = *argp2;
85135   {
85136     try {
85137       (arg1)->SetFocusIndicatorActor(arg2);
85138     } catch (std::out_of_range& e) {
85139       {
85140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85141       };
85142     } catch (std::exception& e) {
85143       {
85144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85145       };
85146     } catch (Dali::DaliException e) {
85147       {
85148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85149       };
85150     } catch (...) {
85151       {
85152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85153       };
85154     }
85155   }
85156
85157 }
85158
85159
85160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85161   void * jresult ;
85162   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85163   Dali::Actor result;
85164
85165   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85166   {
85167     try {
85168       result = (arg1)->GetFocusIndicatorActor();
85169     } catch (std::out_of_range& e) {
85170       {
85171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85172       };
85173     } catch (std::exception& e) {
85174       {
85175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (Dali::DaliException e) {
85178       {
85179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85180       };
85181     } catch (...) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85184       };
85185     }
85186   }
85187
85188   jresult = new Dali::Actor((const Dali::Actor &)result);
85189   return jresult;
85190 }
85191
85192
85193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85194   void * jresult ;
85195   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85196   Dali::Actor arg2 ;
85197   Dali::Actor *argp2 ;
85198   Dali::Actor result;
85199
85200   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85201   argp2 = (Dali::Actor *)jarg2;
85202   if (!argp2) {
85203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85204     return 0;
85205   }
85206   arg2 = *argp2;
85207   {
85208     try {
85209       result = (arg1)->GetFocusGroup(arg2);
85210     } catch (std::out_of_range& e) {
85211       {
85212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85213       };
85214     } catch (std::exception& e) {
85215       {
85216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85217       };
85218     } catch (Dali::DaliException e) {
85219       {
85220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85221       };
85222     } catch (...) {
85223       {
85224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85225       };
85226     }
85227   }
85228
85229   jresult = new Dali::Actor((const Dali::Actor &)result);
85230   return jresult;
85231 }
85232
85233
85234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85235   void * jresult ;
85236   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85237   Dali::Vector2 result;
85238
85239   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85240   {
85241     try {
85242       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85243     } catch (std::out_of_range& e) {
85244       {
85245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85246       };
85247     } catch (std::exception& e) {
85248       {
85249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85250       };
85251     } catch (Dali::DaliException e) {
85252       {
85253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85254       };
85255     } catch (...) {
85256       {
85257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85258       };
85259     }
85260   }
85261
85262   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85263   return jresult;
85264 }
85265
85266
85267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85268   void * jresult ;
85269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85270   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85271
85272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85273   {
85274     try {
85275       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85276     } catch (std::out_of_range& e) {
85277       {
85278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85279       };
85280     } catch (std::exception& e) {
85281       {
85282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85283       };
85284     } catch (Dali::DaliException e) {
85285       {
85286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85287       };
85288     } catch (...) {
85289       {
85290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85291       };
85292     }
85293   }
85294
85295   jresult = (void *)result;
85296   return jresult;
85297 }
85298
85299
85300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85301   void * jresult ;
85302   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85303   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85304
85305   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85306   {
85307     try {
85308       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85309     } catch (std::out_of_range& e) {
85310       {
85311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85312       };
85313     } catch (std::exception& e) {
85314       {
85315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85316       };
85317     } catch (Dali::DaliException e) {
85318       {
85319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85320       };
85321     } catch (...) {
85322       {
85323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85324       };
85325     }
85326   }
85327
85328   jresult = (void *)result;
85329   return jresult;
85330 }
85331
85332
85333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85334   void * jresult ;
85335   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85336   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85337
85338   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85339   {
85340     try {
85341       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85342     } catch (std::out_of_range& e) {
85343       {
85344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85345       };
85346     } catch (std::exception& e) {
85347       {
85348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85349       };
85350     } catch (Dali::DaliException e) {
85351       {
85352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85353       };
85354     } catch (...) {
85355       {
85356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85357       };
85358     }
85359   }
85360
85361   jresult = (void *)result;
85362   return jresult;
85363 }
85364
85365
85366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85367   void * jresult ;
85368   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85369   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85370
85371   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85372   {
85373     try {
85374       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85375     } catch (std::out_of_range& e) {
85376       {
85377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85378       };
85379     } catch (std::exception& e) {
85380       {
85381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85382       };
85383     } catch (Dali::DaliException e) {
85384       {
85385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85386       };
85387     } catch (...) {
85388       {
85389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85390       };
85391     }
85392   }
85393
85394   jresult = (void *)result;
85395   return jresult;
85396 }
85397
85398
85399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85400   void * jresult ;
85401   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85402   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85403
85404   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85405   {
85406     try {
85407       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85408     } catch (std::out_of_range& e) {
85409       {
85410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85411       };
85412     } catch (std::exception& e) {
85413       {
85414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85415       };
85416     } catch (Dali::DaliException e) {
85417       {
85418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85419       };
85420     } catch (...) {
85421       {
85422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85423       };
85424     }
85425   }
85426
85427   jresult = (void *)result;
85428   return jresult;
85429 }
85430
85431
85432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85433   void * jresult ;
85434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85435   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85436
85437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85438   {
85439     try {
85440       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85441     } catch (std::out_of_range& e) {
85442       {
85443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85444       };
85445     } catch (std::exception& e) {
85446       {
85447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85448       };
85449     } catch (Dali::DaliException e) {
85450       {
85451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85452       };
85453     } catch (...) {
85454       {
85455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85456       };
85457     }
85458   }
85459
85460   jresult = (void *)result;
85461   return jresult;
85462 }
85463
85464
85465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85466   void * jresult ;
85467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85468   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85469
85470   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85471   {
85472     try {
85473       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85474     } catch (std::out_of_range& e) {
85475       {
85476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85477       };
85478     } catch (std::exception& e) {
85479       {
85480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85481       };
85482     } catch (Dali::DaliException e) {
85483       {
85484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85485       };
85486     } catch (...) {
85487       {
85488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85489       };
85490     }
85491   }
85492
85493   jresult = (void *)result;
85494   return jresult;
85495 }
85496
85497
85498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85499   void * jresult ;
85500   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85501   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85502
85503   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85504   {
85505     try {
85506       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85507     } catch (std::out_of_range& e) {
85508       {
85509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85510       };
85511     } catch (std::exception& e) {
85512       {
85513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85514       };
85515     } catch (Dali::DaliException e) {
85516       {
85517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85518       };
85519     } catch (...) {
85520       {
85521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85522       };
85523     }
85524   }
85525
85526   jresult = (void *)result;
85527   return jresult;
85528 }
85529
85530
85531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85532   void * jresult ;
85533   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85534   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85535
85536   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85537   {
85538     try {
85539       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85540     } catch (std::out_of_range& e) {
85541       {
85542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85543       };
85544     } catch (std::exception& e) {
85545       {
85546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85547       };
85548     } catch (Dali::DaliException e) {
85549       {
85550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85551       };
85552     } catch (...) {
85553       {
85554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85555       };
85556     }
85557   }
85558
85559   jresult = (void *)result;
85560   return jresult;
85561 }
85562
85563
85564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85565   void * jresult ;
85566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85567   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85568
85569   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85570   {
85571     try {
85572       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85573     } catch (std::out_of_range& e) {
85574       {
85575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85576       };
85577     } catch (std::exception& e) {
85578       {
85579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85580       };
85581     } catch (Dali::DaliException e) {
85582       {
85583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85584       };
85585     } catch (...) {
85586       {
85587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85588       };
85589     }
85590   }
85591
85592   jresult = (void *)result;
85593   return jresult;
85594 }
85595
85596
85597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85598   void * jresult ;
85599   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85600   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85601
85602   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85603   {
85604     try {
85605       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85606     } catch (std::out_of_range& e) {
85607       {
85608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85609       };
85610     } catch (std::exception& e) {
85611       {
85612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (Dali::DaliException e) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85617       };
85618     } catch (...) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85621       };
85622     }
85623   }
85624
85625   jresult = (void *)result;
85626   return jresult;
85627 }
85628
85629
85630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85631   void * jresult ;
85632   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85633   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85634
85635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85636   {
85637     try {
85638       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85639     } catch (std::out_of_range& e) {
85640       {
85641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85642       };
85643     } catch (std::exception& e) {
85644       {
85645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85646       };
85647     } catch (Dali::DaliException e) {
85648       {
85649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85650       };
85651     } catch (...) {
85652       {
85653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85654       };
85655     }
85656   }
85657
85658   jresult = (void *)result;
85659   return jresult;
85660 }
85661
85662
85663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85664   void * jresult ;
85665   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85666   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85667
85668   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85669   {
85670     try {
85671       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85672     } catch (std::out_of_range& e) {
85673       {
85674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85675       };
85676     } catch (std::exception& e) {
85677       {
85678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85679       };
85680     } catch (Dali::DaliException e) {
85681       {
85682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85683       };
85684     } catch (...) {
85685       {
85686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85687       };
85688     }
85689   }
85690
85691   jresult = (void *)result;
85692   return jresult;
85693 }
85694
85695
85696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85697   void * jresult ;
85698   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85699   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85700
85701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85702   {
85703     try {
85704       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85705     } catch (std::out_of_range& e) {
85706       {
85707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85708       };
85709     } catch (std::exception& e) {
85710       {
85711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85712       };
85713     } catch (Dali::DaliException e) {
85714       {
85715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85716       };
85717     } catch (...) {
85718       {
85719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85720       };
85721     }
85722   }
85723
85724   jresult = (void *)result;
85725   return jresult;
85726 }
85727
85728
85729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85730   void * jresult ;
85731   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85732   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85733
85734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85735   {
85736     try {
85737       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85738     } catch (std::out_of_range& e) {
85739       {
85740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85741       };
85742     } catch (std::exception& e) {
85743       {
85744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85745       };
85746     } catch (Dali::DaliException e) {
85747       {
85748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85749       };
85750     } catch (...) {
85751       {
85752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85753       };
85754     }
85755   }
85756
85757   jresult = (void *)result;
85758   return jresult;
85759 }
85760
85761
85762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85763   void * jresult ;
85764   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85765   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85766
85767   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85768   {
85769     try {
85770       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85771     } catch (std::out_of_range& e) {
85772       {
85773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85774       };
85775     } catch (std::exception& e) {
85776       {
85777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85778       };
85779     } catch (Dali::DaliException e) {
85780       {
85781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85782       };
85783     } catch (...) {
85784       {
85785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85786       };
85787     }
85788   }
85789
85790   jresult = (void *)result;
85791   return jresult;
85792 }
85793
85794
85795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85796   void * jresult ;
85797   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85798   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85799
85800   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85801   {
85802     try {
85803       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85804     } catch (std::out_of_range& e) {
85805       {
85806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85807       };
85808     } catch (std::exception& e) {
85809       {
85810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85811       };
85812     } catch (Dali::DaliException e) {
85813       {
85814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85815       };
85816     } catch (...) {
85817       {
85818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85819       };
85820     }
85821   }
85822
85823   jresult = (void *)result;
85824   return jresult;
85825 }
85826
85827
85828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85829   void * jresult ;
85830   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85831   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85832
85833   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85834   {
85835     try {
85836       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85837     } catch (std::out_of_range& e) {
85838       {
85839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85840       };
85841     } catch (std::exception& e) {
85842       {
85843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85844       };
85845     } catch (Dali::DaliException e) {
85846       {
85847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85848       };
85849     } catch (...) {
85850       {
85851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85852       };
85853     }
85854   }
85855
85856   jresult = (void *)result;
85857   return jresult;
85858 }
85859
85860
85861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85862   void * jresult ;
85863   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85864   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85865
85866   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85867   {
85868     try {
85869       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85870     } catch (std::out_of_range& e) {
85871       {
85872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85873       };
85874     } catch (std::exception& e) {
85875       {
85876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85877       };
85878     } catch (Dali::DaliException e) {
85879       {
85880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85881       };
85882     } catch (...) {
85883       {
85884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85885       };
85886     }
85887   }
85888
85889   jresult = (void *)result;
85890   return jresult;
85891 }
85892
85893
85894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85895   void * jresult ;
85896   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85897   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85898
85899   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85900   {
85901     try {
85902       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85903     } catch (std::out_of_range& e) {
85904       {
85905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85906       };
85907     } catch (std::exception& e) {
85908       {
85909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85910       };
85911     } catch (Dali::DaliException e) {
85912       {
85913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85914       };
85915     } catch (...) {
85916       {
85917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85918       };
85919     }
85920   }
85921
85922   jresult = (void *)result;
85923   return jresult;
85924 }
85925
85926
85927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85928   void * jresult ;
85929   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85930   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85931
85932   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85933   {
85934     try {
85935       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85936     } catch (std::out_of_range& e) {
85937       {
85938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (std::exception& e) {
85941       {
85942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85943       };
85944     } catch (Dali::DaliException e) {
85945       {
85946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85947       };
85948     } catch (...) {
85949       {
85950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85951       };
85952     }
85953   }
85954
85955   jresult = (void *)result;
85956   return jresult;
85957 }
85958
85959
85960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85961   void * jresult ;
85962   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85963   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85964
85965   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85966   {
85967     try {
85968       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85969     } catch (std::out_of_range& e) {
85970       {
85971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85972       };
85973     } catch (std::exception& e) {
85974       {
85975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85976       };
85977     } catch (Dali::DaliException e) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85980       };
85981     } catch (...) {
85982       {
85983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85984       };
85985     }
85986   }
85987
85988   jresult = (void *)result;
85989   return jresult;
85990 }
85991
85992
85993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85994   void * jresult ;
85995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85996   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85997
85998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85999   {
86000     try {
86001       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86002     } catch (std::out_of_range& e) {
86003       {
86004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86005       };
86006     } catch (std::exception& e) {
86007       {
86008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86009       };
86010     } catch (Dali::DaliException e) {
86011       {
86012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86013       };
86014     } catch (...) {
86015       {
86016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86017       };
86018     }
86019   }
86020
86021   jresult = (void *)result;
86022   return jresult;
86023 }
86024
86025
86026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86027   void * jresult ;
86028   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86029   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86030
86031   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86032   {
86033     try {
86034       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86035     } catch (std::out_of_range& e) {
86036       {
86037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86038       };
86039     } catch (std::exception& e) {
86040       {
86041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86042       };
86043     } catch (Dali::DaliException e) {
86044       {
86045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86046       };
86047     } catch (...) {
86048       {
86049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86050       };
86051     }
86052   }
86053
86054   jresult = (void *)result;
86055   return jresult;
86056 }
86057
86058
86059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86060   void * jresult ;
86061   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86062   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86063
86064   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86065   {
86066     try {
86067       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86068     } catch (std::out_of_range& e) {
86069       {
86070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86071       };
86072     } catch (std::exception& e) {
86073       {
86074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86075       };
86076     } catch (Dali::DaliException e) {
86077       {
86078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86079       };
86080     } catch (...) {
86081       {
86082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86083       };
86084     }
86085   }
86086
86087   jresult = (void *)result;
86088   return jresult;
86089 }
86090
86091
86092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86093   void * jresult ;
86094   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86095   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86096
86097   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86098   {
86099     try {
86100       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86101     } catch (std::out_of_range& e) {
86102       {
86103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86104       };
86105     } catch (std::exception& e) {
86106       {
86107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86108       };
86109     } catch (Dali::DaliException e) {
86110       {
86111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86112       };
86113     } catch (...) {
86114       {
86115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86116       };
86117     }
86118   }
86119
86120   jresult = (void *)result;
86121   return jresult;
86122 }
86123
86124
86125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86126   void * jresult ;
86127   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86128   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86129
86130   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86131   {
86132     try {
86133       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86134     } catch (std::out_of_range& e) {
86135       {
86136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86137       };
86138     } catch (std::exception& e) {
86139       {
86140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86141       };
86142     } catch (Dali::DaliException e) {
86143       {
86144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86145       };
86146     } catch (...) {
86147       {
86148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86149       };
86150     }
86151   }
86152
86153   jresult = (void *)result;
86154   return jresult;
86155 }
86156
86157
86158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86159   void * jresult ;
86160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86161   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86162
86163   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86164   {
86165     try {
86166       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86167     } catch (std::out_of_range& e) {
86168       {
86169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86170       };
86171     } catch (std::exception& e) {
86172       {
86173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86174       };
86175     } catch (Dali::DaliException e) {
86176       {
86177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86178       };
86179     } catch (...) {
86180       {
86181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86182       };
86183     }
86184   }
86185
86186   jresult = (void *)result;
86187   return jresult;
86188 }
86189
86190
86191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86192   void * jresult ;
86193   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86194   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86195
86196   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86197   {
86198     try {
86199       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86200     } catch (std::out_of_range& e) {
86201       {
86202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86203       };
86204     } catch (std::exception& e) {
86205       {
86206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86207       };
86208     } catch (Dali::DaliException e) {
86209       {
86210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86211       };
86212     } catch (...) {
86213       {
86214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86215       };
86216     }
86217   }
86218
86219   jresult = (void *)result;
86220   return jresult;
86221 }
86222
86223
86224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86225   void * jresult ;
86226   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86227   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86228
86229   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86230   {
86231     try {
86232       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86233     } catch (std::out_of_range& e) {
86234       {
86235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86236       };
86237     } catch (std::exception& e) {
86238       {
86239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86240       };
86241     } catch (Dali::DaliException e) {
86242       {
86243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86244       };
86245     } catch (...) {
86246       {
86247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86248       };
86249     }
86250   }
86251
86252   jresult = (void *)result;
86253   return jresult;
86254 }
86255
86256
86257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86258   void * jresult ;
86259   Dali::Toolkit::StyleManager *result = 0 ;
86260
86261   {
86262     try {
86263       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86264     } catch (std::out_of_range& e) {
86265       {
86266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86267       };
86268     } catch (std::exception& e) {
86269       {
86270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86271       };
86272     } catch (Dali::DaliException e) {
86273       {
86274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86275       };
86276     } catch (...) {
86277       {
86278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86279       };
86280     }
86281   }
86282
86283   jresult = (void *)result;
86284   return jresult;
86285 }
86286
86287
86288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86289   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86290
86291   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86292   {
86293     try {
86294       delete arg1;
86295     } catch (std::out_of_range& e) {
86296       {
86297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86298       };
86299     } catch (std::exception& e) {
86300       {
86301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86302       };
86303     } catch (Dali::DaliException e) {
86304       {
86305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86306       };
86307     } catch (...) {
86308       {
86309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86310       };
86311     }
86312   }
86313
86314 }
86315
86316
86317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86318   void * jresult ;
86319   Dali::Toolkit::StyleManager result;
86320
86321   {
86322     try {
86323       result = Dali::Toolkit::StyleManager::Get();
86324     } catch (std::out_of_range& e) {
86325       {
86326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86327       };
86328     } catch (std::exception& e) {
86329       {
86330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (Dali::DaliException e) {
86333       {
86334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86335       };
86336     } catch (...) {
86337       {
86338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86339       };
86340     }
86341   }
86342
86343   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86344   return jresult;
86345 }
86346
86347
86348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86349   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86350   std::string *arg2 = 0 ;
86351
86352   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86353   if (!jarg2) {
86354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86355     return ;
86356   }
86357   std::string arg2_str(jarg2);
86358   arg2 = &arg2_str;
86359   {
86360     try {
86361       (arg1)->ApplyTheme((std::string const &)*arg2);
86362     } catch (std::out_of_range& e) {
86363       {
86364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86365       };
86366     } catch (std::exception& e) {
86367       {
86368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86369       };
86370     } catch (Dali::DaliException e) {
86371       {
86372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86373       };
86374     } catch (...) {
86375       {
86376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86377       };
86378     }
86379   }
86380
86381
86382   //argout typemap for const std::string&
86383
86384 }
86385
86386
86387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86388   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86389
86390   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86391   {
86392     try {
86393       (arg1)->ApplyDefaultTheme();
86394     } catch (std::out_of_range& e) {
86395       {
86396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86397       };
86398     } catch (std::exception& e) {
86399       {
86400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86401       };
86402     } catch (Dali::DaliException e) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86405       };
86406     } catch (...) {
86407       {
86408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86409       };
86410     }
86411   }
86412
86413 }
86414
86415
86416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86417   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86418   std::string *arg2 = 0 ;
86419   Dali::Property::Value *arg3 = 0 ;
86420
86421   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86422   if (!jarg2) {
86423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86424     return ;
86425   }
86426   std::string arg2_str(jarg2);
86427   arg2 = &arg2_str;
86428   arg3 = (Dali::Property::Value *)jarg3;
86429   if (!arg3) {
86430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86431     return ;
86432   }
86433   {
86434     try {
86435       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86436     } catch (std::out_of_range& e) {
86437       {
86438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86439       };
86440     } catch (std::exception& e) {
86441       {
86442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86443       };
86444     } catch (Dali::DaliException e) {
86445       {
86446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86447       };
86448     } catch (...) {
86449       {
86450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86451       };
86452     }
86453   }
86454
86455
86456   //argout typemap for const std::string&
86457
86458 }
86459
86460
86461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86462   unsigned int jresult ;
86463   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86464   std::string *arg2 = 0 ;
86465   Dali::Property::Value *arg3 = 0 ;
86466   bool result;
86467
86468   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86469   if (!jarg2) {
86470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86471     return 0;
86472   }
86473   std::string arg2_str(jarg2);
86474   arg2 = &arg2_str;
86475   arg3 = (Dali::Property::Value *)jarg3;
86476   if (!arg3) {
86477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86478     return 0;
86479   }
86480   {
86481     try {
86482       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86483     } catch (std::out_of_range& e) {
86484       {
86485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86486       };
86487     } catch (std::exception& e) {
86488       {
86489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (Dali::DaliException e) {
86492       {
86493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86494       };
86495     } catch (...) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86498       };
86499     }
86500   }
86501
86502   jresult = result;
86503
86504   //argout typemap for const std::string&
86505
86506   return jresult;
86507 }
86508
86509
86510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86511   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86512   Dali::Toolkit::Control arg2 ;
86513   std::string *arg3 = 0 ;
86514   std::string *arg4 = 0 ;
86515   Dali::Toolkit::Control *argp2 ;
86516
86517   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86518   argp2 = (Dali::Toolkit::Control *)jarg2;
86519   if (!argp2) {
86520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86521     return ;
86522   }
86523   arg2 = *argp2;
86524   if (!jarg3) {
86525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86526     return ;
86527   }
86528   std::string arg3_str(jarg3);
86529   arg3 = &arg3_str;
86530   if (!jarg4) {
86531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86532     return ;
86533   }
86534   std::string arg4_str(jarg4);
86535   arg4 = &arg4_str;
86536   {
86537     try {
86538       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86539     } catch (std::out_of_range& e) {
86540       {
86541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86542       };
86543     } catch (std::exception& e) {
86544       {
86545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86546       };
86547     } catch (Dali::DaliException e) {
86548       {
86549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86550       };
86551     } catch (...) {
86552       {
86553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86554       };
86555     }
86556   }
86557
86558
86559   //argout typemap for const std::string&
86560
86561
86562   //argout typemap for const std::string&
86563
86564 }
86565
86566
86567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86568   void * jresult ;
86569   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86570   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86571
86572   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86573   {
86574     try {
86575       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86576     } catch (std::out_of_range& e) {
86577       {
86578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86579       };
86580     } catch (std::exception& e) {
86581       {
86582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86583       };
86584     } catch (Dali::DaliException e) {
86585       {
86586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86587       };
86588     } catch (...) {
86589       {
86590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86591       };
86592     }
86593   }
86594
86595   jresult = (void *)result;
86596   return jresult;
86597 }
86598
86599
86600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86601   int jresult ;
86602   int result;
86603
86604   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86605   jresult = (int)result;
86606   return jresult;
86607 }
86608
86609
86610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86611   int jresult ;
86612   int result;
86613
86614   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86615   jresult = (int)result;
86616   return jresult;
86617 }
86618
86619
86620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86621   int jresult ;
86622   int result;
86623
86624   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86625   jresult = (int)result;
86626   return jresult;
86627 }
86628
86629
86630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86631   int jresult ;
86632   int result;
86633
86634   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86635   jresult = (int)result;
86636   return jresult;
86637 }
86638
86639
86640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86641   int jresult ;
86642   int result;
86643
86644   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86645   jresult = (int)result;
86646   return jresult;
86647 }
86648
86649
86650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86651   int jresult ;
86652   int result;
86653
86654   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86655   jresult = (int)result;
86656   return jresult;
86657 }
86658
86659
86660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86661   int jresult ;
86662   int result;
86663
86664   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86665   jresult = (int)result;
86666   return jresult;
86667 }
86668
86669
86670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86671   int jresult ;
86672   int result;
86673
86674   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86675   jresult = (int)result;
86676   return jresult;
86677 }
86678
86679
86680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86681   int jresult ;
86682   int result;
86683
86684   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86685   jresult = (int)result;
86686   return jresult;
86687 }
86688
86689
86690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86691   int jresult ;
86692   int result;
86693
86694   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86695   jresult = (int)result;
86696   return jresult;
86697 }
86698
86699
86700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86701   int jresult ;
86702   int result;
86703
86704   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86705   jresult = (int)result;
86706   return jresult;
86707 }
86708
86709
86710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86711   int jresult ;
86712   int result;
86713
86714   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86715   jresult = (int)result;
86716   return jresult;
86717 }
86718
86719
86720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86721   int jresult ;
86722   int result;
86723
86724   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86725   jresult = (int)result;
86726   return jresult;
86727 }
86728
86729
86730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86731   int jresult ;
86732   int result;
86733
86734   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86735   jresult = (int)result;
86736   return jresult;
86737 }
86738
86739
86740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86741   int jresult ;
86742   int result;
86743
86744   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86745   jresult = (int)result;
86746   return jresult;
86747 }
86748
86749
86750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86751   void * jresult ;
86752   Dali::Toolkit::Slider::Property *result = 0 ;
86753
86754   {
86755     try {
86756       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86757     } catch (std::out_of_range& e) {
86758       {
86759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86760       };
86761     } catch (std::exception& e) {
86762       {
86763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86764       };
86765     } catch (Dali::DaliException e) {
86766       {
86767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86768       };
86769     } catch (...) {
86770       {
86771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86772       };
86773     }
86774   }
86775
86776   jresult = (void *)result;
86777   return jresult;
86778 }
86779
86780
86781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86782   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86783
86784   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86785   {
86786     try {
86787       delete arg1;
86788     } catch (std::out_of_range& e) {
86789       {
86790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86791       };
86792     } catch (std::exception& e) {
86793       {
86794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86795       };
86796     } catch (Dali::DaliException e) {
86797       {
86798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86799       };
86800     } catch (...) {
86801       {
86802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86803       };
86804     }
86805   }
86806
86807 }
86808
86809
86810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86811   void * jresult ;
86812   Dali::Toolkit::Slider result;
86813
86814   {
86815     try {
86816       result = Dali::Toolkit::Slider::New();
86817     } catch (std::out_of_range& e) {
86818       {
86819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86820       };
86821     } catch (std::exception& e) {
86822       {
86823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86824       };
86825     } catch (Dali::DaliException e) {
86826       {
86827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86828       };
86829     } catch (...) {
86830       {
86831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86832       };
86833     }
86834   }
86835
86836   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86837   return jresult;
86838 }
86839
86840
86841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86842   void * jresult ;
86843   Dali::Toolkit::Slider *result = 0 ;
86844
86845   {
86846     try {
86847       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86848     } catch (std::out_of_range& e) {
86849       {
86850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86851       };
86852     } catch (std::exception& e) {
86853       {
86854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86855       };
86856     } catch (Dali::DaliException e) {
86857       {
86858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86859       };
86860     } catch (...) {
86861       {
86862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86863       };
86864     }
86865   }
86866
86867   jresult = (void *)result;
86868   return jresult;
86869 }
86870
86871
86872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86873   void * jresult ;
86874   Dali::Toolkit::Slider *arg1 = 0 ;
86875   Dali::Toolkit::Slider *result = 0 ;
86876
86877   arg1 = (Dali::Toolkit::Slider *)jarg1;
86878   if (!arg1) {
86879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86880     return 0;
86881   }
86882   {
86883     try {
86884       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86885     } catch (std::out_of_range& e) {
86886       {
86887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (std::exception& e) {
86890       {
86891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86892       };
86893     } catch (Dali::DaliException e) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86896       };
86897     } catch (...) {
86898       {
86899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86900       };
86901     }
86902   }
86903
86904   jresult = (void *)result;
86905   return jresult;
86906 }
86907
86908
86909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86910   void * jresult ;
86911   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86912   Dali::Toolkit::Slider *arg2 = 0 ;
86913   Dali::Toolkit::Slider *result = 0 ;
86914
86915   arg1 = (Dali::Toolkit::Slider *)jarg1;
86916   arg2 = (Dali::Toolkit::Slider *)jarg2;
86917   if (!arg2) {
86918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86919     return 0;
86920   }
86921   {
86922     try {
86923       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86924     } catch (std::out_of_range& e) {
86925       {
86926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86927       };
86928     } catch (std::exception& e) {
86929       {
86930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86931       };
86932     } catch (Dali::DaliException e) {
86933       {
86934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86935       };
86936     } catch (...) {
86937       {
86938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86939       };
86940     }
86941   }
86942
86943   jresult = (void *)result;
86944   return jresult;
86945 }
86946
86947
86948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86949   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86950
86951   arg1 = (Dali::Toolkit::Slider *)jarg1;
86952   {
86953     try {
86954       delete arg1;
86955     } catch (std::out_of_range& e) {
86956       {
86957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86958       };
86959     } catch (std::exception& e) {
86960       {
86961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86962       };
86963     } catch (Dali::DaliException e) {
86964       {
86965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86966       };
86967     } catch (...) {
86968       {
86969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86970       };
86971     }
86972   }
86973
86974 }
86975
86976
86977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86978   void * jresult ;
86979   Dali::BaseHandle arg1 ;
86980   Dali::BaseHandle *argp1 ;
86981   Dali::Toolkit::Slider result;
86982
86983   argp1 = (Dali::BaseHandle *)jarg1;
86984   if (!argp1) {
86985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86986     return 0;
86987   }
86988   arg1 = *argp1;
86989   {
86990     try {
86991       result = Dali::Toolkit::Slider::DownCast(arg1);
86992     } catch (std::out_of_range& e) {
86993       {
86994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86995       };
86996     } catch (std::exception& e) {
86997       {
86998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86999       };
87000     } catch (Dali::DaliException e) {
87001       {
87002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87003       };
87004     } catch (...) {
87005       {
87006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87007       };
87008     }
87009   }
87010
87011   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87012   return jresult;
87013 }
87014
87015
87016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87017   void * jresult ;
87018   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87019   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87020
87021   arg1 = (Dali::Toolkit::Slider *)jarg1;
87022   {
87023     try {
87024       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87025     } catch (std::out_of_range& e) {
87026       {
87027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87028       };
87029     } catch (std::exception& e) {
87030       {
87031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87032       };
87033     } catch (Dali::DaliException e) {
87034       {
87035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87036       };
87037     } catch (...) {
87038       {
87039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87040       };
87041     }
87042   }
87043
87044   jresult = (void *)result;
87045   return jresult;
87046 }
87047
87048
87049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87050   void * jresult ;
87051   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87052   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87053
87054   arg1 = (Dali::Toolkit::Slider *)jarg1;
87055   {
87056     try {
87057       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87058     } catch (std::out_of_range& e) {
87059       {
87060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87061       };
87062     } catch (std::exception& e) {
87063       {
87064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87065       };
87066     } catch (Dali::DaliException e) {
87067       {
87068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87069       };
87070     } catch (...) {
87071       {
87072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87073       };
87074     }
87075   }
87076
87077   jresult = (void *)result;
87078   return jresult;
87079 }
87080
87081
87082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87083   void * jresult ;
87084   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87085   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87086
87087   arg1 = (Dali::Toolkit::Slider *)jarg1;
87088   {
87089     try {
87090       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87091     } catch (std::out_of_range& e) {
87092       {
87093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87094       };
87095     } catch (std::exception& e) {
87096       {
87097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87098       };
87099     } catch (Dali::DaliException e) {
87100       {
87101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87102       };
87103     } catch (...) {
87104       {
87105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87106       };
87107     }
87108   }
87109
87110   jresult = (void *)result;
87111   return jresult;
87112 }
87113
87114
87115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87116   int jresult ;
87117   int result;
87118
87119   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87120   jresult = (int)result;
87121   return jresult;
87122 }
87123
87124
87125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87126   int jresult ;
87127   int result;
87128
87129   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87130   jresult = (int)result;
87131   return jresult;
87132 }
87133
87134
87135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87136   int jresult ;
87137   int result;
87138
87139   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87140   jresult = (int)result;
87141   return jresult;
87142 }
87143
87144
87145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87146   int jresult ;
87147   int result;
87148
87149   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87150   jresult = (int)result;
87151   return jresult;
87152 }
87153
87154
87155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87156   int result;
87157
87158   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87159
87160   return result;
87161 }
87162
87163
87164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87165   void * jresult ;
87166   Dali::Toolkit::VideoView::Property *result = 0 ;
87167
87168   {
87169     try {
87170       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87171     } catch (std::out_of_range& e) {
87172       {
87173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87174       };
87175     } catch (std::exception& e) {
87176       {
87177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87178       };
87179     } catch (Dali::DaliException e) {
87180       {
87181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87182       };
87183     } catch (...) {
87184       {
87185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87186       };
87187     }
87188   }
87189
87190   jresult = (void *)result;
87191   return jresult;
87192 }
87193
87194
87195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87196   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87197
87198   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87199   {
87200     try {
87201       delete arg1;
87202     } catch (std::out_of_range& e) {
87203       {
87204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87205       };
87206     } catch (std::exception& e) {
87207       {
87208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87209       };
87210     } catch (Dali::DaliException e) {
87211       {
87212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87217       };
87218     }
87219   }
87220
87221 }
87222
87223
87224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87225   void * jresult ;
87226   Dali::Toolkit::VideoView result;
87227
87228   {
87229     try {
87230       result = Dali::Toolkit::VideoView::New();
87231     } catch (std::out_of_range& e) {
87232       {
87233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87234       };
87235     } catch (std::exception& e) {
87236       {
87237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87238       };
87239     } catch (Dali::DaliException e) {
87240       {
87241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87242       };
87243     } catch (...) {
87244       {
87245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87246       };
87247     }
87248   }
87249
87250   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87251   return jresult;
87252 }
87253
87254
87255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87256   void * jresult ;
87257   std::string *arg1 = 0 ;
87258   Dali::Toolkit::VideoView result;
87259
87260   if (!jarg1) {
87261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87262     return 0;
87263   }
87264   std::string arg1_str(jarg1);
87265   arg1 = &arg1_str;
87266   {
87267     try {
87268       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87269     } catch (std::out_of_range& e) {
87270       {
87271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87272       };
87273     } catch (std::exception& e) {
87274       {
87275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87276       };
87277     } catch (Dali::DaliException e) {
87278       {
87279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87280       };
87281     } catch (...) {
87282       {
87283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87284       };
87285     }
87286   }
87287
87288   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87289
87290   //argout typemap for const std::string&
87291
87292   return jresult;
87293 }
87294
87295
87296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87297   void * jresult ;
87298   Dali::Toolkit::VideoView *result = 0 ;
87299
87300   {
87301     try {
87302       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87303     } catch (std::out_of_range& e) {
87304       {
87305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87306       };
87307     } catch (std::exception& e) {
87308       {
87309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87310       };
87311     } catch (Dali::DaliException e) {
87312       {
87313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87314       };
87315     } catch (...) {
87316       {
87317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87318       };
87319     }
87320   }
87321
87322   jresult = (void *)result;
87323   return jresult;
87324 }
87325
87326
87327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87328   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87329
87330   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87331   {
87332     try {
87333       delete arg1;
87334     } catch (std::out_of_range& e) {
87335       {
87336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87337       };
87338     } catch (std::exception& e) {
87339       {
87340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87341       };
87342     } catch (Dali::DaliException e) {
87343       {
87344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87345       };
87346     } catch (...) {
87347       {
87348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87349       };
87350     }
87351   }
87352
87353 }
87354
87355
87356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87357   void * jresult ;
87358   Dali::Toolkit::VideoView *arg1 = 0 ;
87359   Dali::Toolkit::VideoView *result = 0 ;
87360
87361   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87362   if (!arg1) {
87363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87364     return 0;
87365   }
87366   {
87367     try {
87368       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87369     } catch (std::out_of_range& e) {
87370       {
87371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87372       };
87373     } catch (std::exception& e) {
87374       {
87375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87376       };
87377     } catch (Dali::DaliException e) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87380       };
87381     } catch (...) {
87382       {
87383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87384       };
87385     }
87386   }
87387
87388   jresult = (void *)result;
87389   return jresult;
87390 }
87391
87392
87393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87394   void * jresult ;
87395   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87396   Dali::Toolkit::VideoView *arg2 = 0 ;
87397   Dali::Toolkit::VideoView *result = 0 ;
87398
87399   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87400   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87401   if (!arg2) {
87402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87403     return 0;
87404   }
87405   {
87406     try {
87407       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87408     } catch (std::out_of_range& e) {
87409       {
87410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87411       };
87412     } catch (std::exception& e) {
87413       {
87414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87415       };
87416     } catch (Dali::DaliException e) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87419       };
87420     } catch (...) {
87421       {
87422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87423       };
87424     }
87425   }
87426
87427   jresult = (void *)result;
87428   return jresult;
87429 }
87430
87431
87432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87433   void * jresult ;
87434   Dali::BaseHandle arg1 ;
87435   Dali::BaseHandle *argp1 ;
87436   Dali::Toolkit::VideoView result;
87437
87438   argp1 = (Dali::BaseHandle *)jarg1;
87439   if (!argp1) {
87440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87441     return 0;
87442   }
87443   arg1 = *argp1;
87444   {
87445     try {
87446       result = Dali::Toolkit::VideoView::DownCast(arg1);
87447     } catch (std::out_of_range& e) {
87448       {
87449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87450       };
87451     } catch (std::exception& e) {
87452       {
87453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87454       };
87455     } catch (Dali::DaliException e) {
87456       {
87457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87458       };
87459     } catch (...) {
87460       {
87461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87462       };
87463     }
87464   }
87465
87466   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87467   return jresult;
87468 }
87469
87470
87471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87472   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87473
87474   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87475   {
87476     try {
87477       (arg1)->Play();
87478     } catch (std::out_of_range& e) {
87479       {
87480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87481       };
87482     } catch (std::exception& e) {
87483       {
87484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87485       };
87486     } catch (Dali::DaliException e) {
87487       {
87488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87489       };
87490     } catch (...) {
87491       {
87492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87493       };
87494     }
87495   }
87496
87497 }
87498
87499
87500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87501   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87502
87503   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87504   {
87505     try {
87506       (arg1)->Pause();
87507     } catch (std::out_of_range& e) {
87508       {
87509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87510       };
87511     } catch (std::exception& e) {
87512       {
87513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87514       };
87515     } catch (Dali::DaliException e) {
87516       {
87517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87518       };
87519     } catch (...) {
87520       {
87521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87522       };
87523     }
87524   }
87525
87526 }
87527
87528
87529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87530   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87531
87532   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87533   {
87534     try {
87535       (arg1)->Stop();
87536     } catch (std::out_of_range& e) {
87537       {
87538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87539       };
87540     } catch (std::exception& e) {
87541       {
87542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87543       };
87544     } catch (Dali::DaliException e) {
87545       {
87546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87547       };
87548     } catch (...) {
87549       {
87550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87551       };
87552     }
87553   }
87554
87555 }
87556
87557
87558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87559   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87560   int arg2 ;
87561
87562   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87563   arg2 = (int)jarg2;
87564   {
87565     try {
87566       (arg1)->Forward(arg2);
87567     } catch (std::out_of_range& e) {
87568       {
87569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87570       };
87571     } catch (std::exception& e) {
87572       {
87573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87574       };
87575     } catch (Dali::DaliException e) {
87576       {
87577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87578       };
87579     } catch (...) {
87580       {
87581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87582       };
87583     }
87584   }
87585
87586 }
87587
87588
87589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87590   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87591   int arg2 ;
87592
87593   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87594   arg2 = (int)jarg2;
87595   {
87596     try {
87597       (arg1)->Backward(arg2);
87598     } catch (std::out_of_range& e) {
87599       {
87600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87601       };
87602     } catch (std::exception& e) {
87603       {
87604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87605       };
87606     } catch (Dali::DaliException e) {
87607       {
87608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87609       };
87610     } catch (...) {
87611       {
87612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87613       };
87614     }
87615   }
87616
87617 }
87618
87619
87620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87621   void * jresult ;
87622   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87623   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87624
87625   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87626   {
87627     try {
87628       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87629     } catch (std::out_of_range& e) {
87630       {
87631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87632       };
87633     } catch (std::exception& e) {
87634       {
87635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87636       };
87637     } catch (Dali::DaliException e) {
87638       {
87639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87640       };
87641     } catch (...) {
87642       {
87643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87644       };
87645     }
87646   }
87647
87648   jresult = (void *)result;
87649   return jresult;
87650 }
87651
87652
87653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87654   int jresult ;
87655   int result;
87656
87657   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87658   jresult = (int)result;
87659   return jresult;
87660 }
87661
87662
87663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87664   int jresult ;
87665   int result;
87666
87667   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87668   jresult = (int)result;
87669   return jresult;
87670 }
87671
87672
87673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87674   int jresult ;
87675   int result;
87676
87677   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87678   jresult = (int)result;
87679   return jresult;
87680 }
87681
87682
87683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87684   int jresult ;
87685   int result;
87686
87687   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87688   jresult = (int)result;
87689   return jresult;
87690 }
87691
87692
87693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87694   int jresult ;
87695   int result;
87696
87697   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87698   jresult = (int)result;
87699   return jresult;
87700 }
87701
87702
87703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87704   int jresult ;
87705   int result;
87706
87707   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87708   jresult = (int)result;
87709   return jresult;
87710 }
87711
87712
87713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87714   int jresult ;
87715   int result;
87716
87717   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87718   jresult = (int)result;
87719   return jresult;
87720 }
87721
87722
87723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87724   int jresult ;
87725   int result;
87726
87727   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87728   jresult = (int)result;
87729   return jresult;
87730 }
87731
87732
87733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87734   int jresult ;
87735   int result;
87736
87737   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87738   jresult = (int)result;
87739   return jresult;
87740 }
87741
87742
87743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87744   int jresult ;
87745   int result;
87746
87747   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87748   jresult = (int)result;
87749   return jresult;
87750 }
87751
87752
87753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87754   int jresult ;
87755   int result;
87756
87757   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87758   jresult = (int)result;
87759   return jresult;
87760 }
87761
87762
87763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87764   int jresult ;
87765   int result;
87766
87767   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87768   jresult = (int)result;
87769   return jresult;
87770 }
87771
87772
87773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87774   int jresult ;
87775   int result;
87776
87777   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87778   jresult = (int)result;
87779   return jresult;
87780 }
87781
87782
87783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87784   int jresult ;
87785   int result;
87786
87787   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87788   jresult = (int)result;
87789   return jresult;
87790 }
87791
87792
87793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87794   int jresult ;
87795   int result;
87796
87797   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87798   jresult = (int)result;
87799   return jresult;
87800 }
87801
87802
87803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87804   int jresult ;
87805   int result;
87806
87807   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87808   jresult = (int)result;
87809   return jresult;
87810 }
87811
87812
87813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87814   int jresult ;
87815   int result;
87816
87817   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87818   jresult = (int)result;
87819   return jresult;
87820 }
87821
87822
87823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87824   int jresult ;
87825   int result;
87826
87827   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87828   jresult = (int)result;
87829   return jresult;
87830 }
87831
87832
87833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87834   int jresult ;
87835   int result;
87836
87837   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87838   jresult = (int)result;
87839   return jresult;
87840 }
87841
87842
87843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87844   int jresult ;
87845   int result;
87846
87847   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87848   jresult = (int)result;
87849   return jresult;
87850 }
87851
87852
87853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87854   int jresult ;
87855   int result;
87856
87857   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87858   jresult = (int)result;
87859   return jresult;
87860 }
87861
87862
87863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87864   void * jresult ;
87865   Dali::Toolkit::Popup::Property *result = 0 ;
87866
87867   {
87868     try {
87869       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87870     } catch (std::out_of_range& e) {
87871       {
87872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87873       };
87874     } catch (std::exception& e) {
87875       {
87876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87877       };
87878     } catch (Dali::DaliException e) {
87879       {
87880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87881       };
87882     } catch (...) {
87883       {
87884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87885       };
87886     }
87887   }
87888
87889   jresult = (void *)result;
87890   return jresult;
87891 }
87892
87893
87894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87895   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87896
87897   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87898   {
87899     try {
87900       delete arg1;
87901     } catch (std::out_of_range& e) {
87902       {
87903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87904       };
87905     } catch (std::exception& e) {
87906       {
87907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87908       };
87909     } catch (Dali::DaliException e) {
87910       {
87911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87912       };
87913     } catch (...) {
87914       {
87915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87916       };
87917     }
87918   }
87919
87920 }
87921
87922
87923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87924   void * jresult ;
87925   Dali::Toolkit::Popup *result = 0 ;
87926
87927   {
87928     try {
87929       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87930     } catch (std::out_of_range& e) {
87931       {
87932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87933       };
87934     } catch (std::exception& e) {
87935       {
87936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87937       };
87938     } catch (Dali::DaliException e) {
87939       {
87940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87941       };
87942     } catch (...) {
87943       {
87944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87945       };
87946     }
87947   }
87948
87949   jresult = (void *)result;
87950   return jresult;
87951 }
87952
87953
87954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87955   void * jresult ;
87956   Dali::Toolkit::Popup result;
87957
87958   {
87959     try {
87960       result = Dali::Toolkit::Popup::New();
87961     } catch (std::out_of_range& e) {
87962       {
87963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87964       };
87965     } catch (std::exception& e) {
87966       {
87967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87968       };
87969     } catch (Dali::DaliException e) {
87970       {
87971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87972       };
87973     } catch (...) {
87974       {
87975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87976       };
87977     }
87978   }
87979
87980   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87981   return jresult;
87982 }
87983
87984
87985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87986   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87987
87988   arg1 = (Dali::Toolkit::Popup *)jarg1;
87989   {
87990     try {
87991       delete arg1;
87992     } catch (std::out_of_range& e) {
87993       {
87994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87995       };
87996     } catch (std::exception& e) {
87997       {
87998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87999       };
88000     } catch (Dali::DaliException e) {
88001       {
88002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88003       };
88004     } catch (...) {
88005       {
88006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88007       };
88008     }
88009   }
88010
88011 }
88012
88013
88014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88015   void * jresult ;
88016   Dali::Toolkit::Popup *arg1 = 0 ;
88017   Dali::Toolkit::Popup *result = 0 ;
88018
88019   arg1 = (Dali::Toolkit::Popup *)jarg1;
88020   if (!arg1) {
88021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88022     return 0;
88023   }
88024   {
88025     try {
88026       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88027     } catch (std::out_of_range& e) {
88028       {
88029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88030       };
88031     } catch (std::exception& e) {
88032       {
88033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88034       };
88035     } catch (Dali::DaliException e) {
88036       {
88037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88038       };
88039     } catch (...) {
88040       {
88041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88042       };
88043     }
88044   }
88045
88046   jresult = (void *)result;
88047   return jresult;
88048 }
88049
88050
88051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88052   void * jresult ;
88053   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88054   Dali::Toolkit::Popup *arg2 = 0 ;
88055   Dali::Toolkit::Popup *result = 0 ;
88056
88057   arg1 = (Dali::Toolkit::Popup *)jarg1;
88058   arg2 = (Dali::Toolkit::Popup *)jarg2;
88059   if (!arg2) {
88060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88061     return 0;
88062   }
88063   {
88064     try {
88065       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88066     } catch (std::out_of_range& e) {
88067       {
88068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88069       };
88070     } catch (std::exception& e) {
88071       {
88072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88073       };
88074     } catch (Dali::DaliException e) {
88075       {
88076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88077       };
88078     } catch (...) {
88079       {
88080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88081       };
88082     }
88083   }
88084
88085   jresult = (void *)result;
88086   return jresult;
88087 }
88088
88089
88090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88091   void * jresult ;
88092   Dali::BaseHandle arg1 ;
88093   Dali::BaseHandle *argp1 ;
88094   Dali::Toolkit::Popup result;
88095
88096   argp1 = (Dali::BaseHandle *)jarg1;
88097   if (!argp1) {
88098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88099     return 0;
88100   }
88101   arg1 = *argp1;
88102   {
88103     try {
88104       result = Dali::Toolkit::Popup::DownCast(arg1);
88105     } catch (std::out_of_range& e) {
88106       {
88107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88108       };
88109     } catch (std::exception& e) {
88110       {
88111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88112       };
88113     } catch (Dali::DaliException e) {
88114       {
88115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88116       };
88117     } catch (...) {
88118       {
88119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88120       };
88121     }
88122   }
88123
88124   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88125   return jresult;
88126 }
88127
88128
88129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88130   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88131   Dali::Actor arg2 ;
88132   Dali::Actor *argp2 ;
88133
88134   arg1 = (Dali::Toolkit::Popup *)jarg1;
88135   argp2 = (Dali::Actor *)jarg2;
88136   if (!argp2) {
88137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88138     return ;
88139   }
88140   arg2 = *argp2;
88141   {
88142     try {
88143       (arg1)->SetTitle(arg2);
88144     } catch (std::out_of_range& e) {
88145       {
88146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88147       };
88148     } catch (std::exception& e) {
88149       {
88150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88151       };
88152     } catch (Dali::DaliException e) {
88153       {
88154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88155       };
88156     } catch (...) {
88157       {
88158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88159       };
88160     }
88161   }
88162
88163 }
88164
88165
88166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88167   void * jresult ;
88168   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88169   Dali::Actor result;
88170
88171   arg1 = (Dali::Toolkit::Popup *)jarg1;
88172   {
88173     try {
88174       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88175     } catch (std::out_of_range& e) {
88176       {
88177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88178       };
88179     } catch (std::exception& e) {
88180       {
88181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88182       };
88183     } catch (Dali::DaliException e) {
88184       {
88185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88186       };
88187     } catch (...) {
88188       {
88189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88190       };
88191     }
88192   }
88193
88194   jresult = new Dali::Actor((const Dali::Actor &)result);
88195   return jresult;
88196 }
88197
88198
88199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88200   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88201   Dali::Actor arg2 ;
88202   Dali::Actor *argp2 ;
88203
88204   arg1 = (Dali::Toolkit::Popup *)jarg1;
88205   argp2 = (Dali::Actor *)jarg2;
88206   if (!argp2) {
88207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88208     return ;
88209   }
88210   arg2 = *argp2;
88211   {
88212     try {
88213       (arg1)->SetContent(arg2);
88214     } catch (std::out_of_range& e) {
88215       {
88216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88217       };
88218     } catch (std::exception& e) {
88219       {
88220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88221       };
88222     } catch (Dali::DaliException e) {
88223       {
88224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88225       };
88226     } catch (...) {
88227       {
88228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88229       };
88230     }
88231   }
88232
88233 }
88234
88235
88236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88237   void * jresult ;
88238   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88239   Dali::Actor result;
88240
88241   arg1 = (Dali::Toolkit::Popup *)jarg1;
88242   {
88243     try {
88244       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88245     } catch (std::out_of_range& e) {
88246       {
88247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88248       };
88249     } catch (std::exception& e) {
88250       {
88251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88252       };
88253     } catch (Dali::DaliException e) {
88254       {
88255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88256       };
88257     } catch (...) {
88258       {
88259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88260       };
88261     }
88262   }
88263
88264   jresult = new Dali::Actor((const Dali::Actor &)result);
88265   return jresult;
88266 }
88267
88268
88269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88270   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88271   Dali::Actor arg2 ;
88272   Dali::Actor *argp2 ;
88273
88274   arg1 = (Dali::Toolkit::Popup *)jarg1;
88275   argp2 = (Dali::Actor *)jarg2;
88276   if (!argp2) {
88277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88278     return ;
88279   }
88280   arg2 = *argp2;
88281   {
88282     try {
88283       (arg1)->SetFooter(arg2);
88284     } catch (std::out_of_range& e) {
88285       {
88286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88287       };
88288     } catch (std::exception& e) {
88289       {
88290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88291       };
88292     } catch (Dali::DaliException e) {
88293       {
88294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88295       };
88296     } catch (...) {
88297       {
88298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88299       };
88300     }
88301   }
88302
88303 }
88304
88305
88306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88307   void * jresult ;
88308   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88309   Dali::Actor result;
88310
88311   arg1 = (Dali::Toolkit::Popup *)jarg1;
88312   {
88313     try {
88314       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88315     } catch (std::out_of_range& e) {
88316       {
88317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88318       };
88319     } catch (std::exception& e) {
88320       {
88321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88322       };
88323     } catch (Dali::DaliException e) {
88324       {
88325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88326       };
88327     } catch (...) {
88328       {
88329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88330       };
88331     }
88332   }
88333
88334   jresult = new Dali::Actor((const Dali::Actor &)result);
88335   return jresult;
88336 }
88337
88338
88339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88340   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88341   Dali::Toolkit::Popup::DisplayState arg2 ;
88342
88343   arg1 = (Dali::Toolkit::Popup *)jarg1;
88344   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88345   {
88346     try {
88347       (arg1)->SetDisplayState(arg2);
88348     } catch (std::out_of_range& e) {
88349       {
88350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88351       };
88352     } catch (std::exception& e) {
88353       {
88354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88355       };
88356     } catch (Dali::DaliException e) {
88357       {
88358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88359       };
88360     } catch (...) {
88361       {
88362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88363       };
88364     }
88365   }
88366
88367 }
88368
88369
88370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88371   int jresult ;
88372   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88373   Dali::Toolkit::Popup::DisplayState result;
88374
88375   arg1 = (Dali::Toolkit::Popup *)jarg1;
88376   {
88377     try {
88378       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88379     } catch (std::out_of_range& e) {
88380       {
88381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88382       };
88383     } catch (std::exception& e) {
88384       {
88385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88386       };
88387     } catch (Dali::DaliException e) {
88388       {
88389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88390       };
88391     } catch (...) {
88392       {
88393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88394       };
88395     }
88396   }
88397
88398   jresult = (int)result;
88399   return jresult;
88400 }
88401
88402
88403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88404   void * jresult ;
88405   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88406   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88407
88408   arg1 = (Dali::Toolkit::Popup *)jarg1;
88409   {
88410     try {
88411       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88412     } catch (std::out_of_range& e) {
88413       {
88414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88415       };
88416     } catch (std::exception& e) {
88417       {
88418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88419       };
88420     } catch (Dali::DaliException e) {
88421       {
88422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88423       };
88424     } catch (...) {
88425       {
88426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88427       };
88428     }
88429   }
88430
88431   jresult = (void *)result;
88432   return jresult;
88433 }
88434
88435
88436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88437   void * jresult ;
88438   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88439   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88440
88441   arg1 = (Dali::Toolkit::Popup *)jarg1;
88442   {
88443     try {
88444       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88445     } catch (std::out_of_range& e) {
88446       {
88447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88448       };
88449     } catch (std::exception& e) {
88450       {
88451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88452       };
88453     } catch (Dali::DaliException e) {
88454       {
88455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88456       };
88457     } catch (...) {
88458       {
88459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88460       };
88461     }
88462   }
88463
88464   jresult = (void *)result;
88465   return jresult;
88466 }
88467
88468
88469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88470   void * jresult ;
88471   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88472   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88473
88474   arg1 = (Dali::Toolkit::Popup *)jarg1;
88475   {
88476     try {
88477       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
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_HidingSignal(void * jarg1) {
88503   void * jresult ;
88504   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88505   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88506
88507   arg1 = (Dali::Toolkit::Popup *)jarg1;
88508   {
88509     try {
88510       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88511     } catch (std::out_of_range& e) {
88512       {
88513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88514       };
88515     } catch (std::exception& e) {
88516       {
88517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88518       };
88519     } catch (Dali::DaliException e) {
88520       {
88521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88522       };
88523     } catch (...) {
88524       {
88525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88526       };
88527     }
88528   }
88529
88530   jresult = (void *)result;
88531   return jresult;
88532 }
88533
88534
88535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88536   void * jresult ;
88537   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88538   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88539
88540   arg1 = (Dali::Toolkit::Popup *)jarg1;
88541   {
88542     try {
88543       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88544     } catch (std::out_of_range& e) {
88545       {
88546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88547       };
88548     } catch (std::exception& e) {
88549       {
88550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88551       };
88552     } catch (Dali::DaliException e) {
88553       {
88554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88555       };
88556     } catch (...) {
88557       {
88558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88559       };
88560     }
88561   }
88562
88563   jresult = (void *)result;
88564   return jresult;
88565 }
88566
88567
88568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88569   int jresult ;
88570   int result;
88571
88572   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88573   jresult = (int)result;
88574   return jresult;
88575 }
88576
88577
88578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88579   int jresult ;
88580   int result;
88581
88582   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88583   jresult = (int)result;
88584   return jresult;
88585 }
88586
88587
88588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88589   int jresult ;
88590   int result;
88591
88592   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88593   jresult = (int)result;
88594   return jresult;
88595 }
88596
88597
88598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88599   int jresult ;
88600   int result;
88601
88602   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88603   jresult = (int)result;
88604   return jresult;
88605 }
88606
88607
88608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88609   int jresult ;
88610   int result;
88611
88612   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88613   jresult = (int)result;
88614   return jresult;
88615 }
88616
88617
88618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88619   int jresult ;
88620   int result;
88621
88622   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88623   jresult = (int)result;
88624   return jresult;
88625 }
88626
88627
88628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88629   int jresult ;
88630   int result;
88631
88632   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88633   jresult = (int)result;
88634   return jresult;
88635 }
88636
88637
88638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88639   int jresult ;
88640   int result;
88641
88642   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88643   jresult = (int)result;
88644   return jresult;
88645 }
88646
88647
88648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88649   int jresult ;
88650   int result;
88651
88652   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88653   jresult = (int)result;
88654   return jresult;
88655 }
88656
88657
88658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88659   void * jresult ;
88660   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88661
88662   {
88663     try {
88664       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88665     } catch (std::out_of_range& e) {
88666       {
88667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88668       };
88669     } catch (std::exception& e) {
88670       {
88671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88672       };
88673     } catch (Dali::DaliException e) {
88674       {
88675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88676       };
88677     } catch (...) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88680       };
88681     }
88682   }
88683
88684   jresult = (void *)result;
88685   return jresult;
88686 }
88687
88688
88689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88690   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88691
88692   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88693   {
88694     try {
88695       delete arg1;
88696     } catch (std::out_of_range& e) {
88697       {
88698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88699       };
88700     } catch (std::exception& e) {
88701       {
88702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88703       };
88704     } catch (Dali::DaliException e) {
88705       {
88706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88707       };
88708     } catch (...) {
88709       {
88710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88711       };
88712     }
88713   }
88714
88715 }
88716
88717
88718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88719   void * jresult ;
88720   Dali::Toolkit::ProgressBar result;
88721
88722   {
88723     try {
88724       result = Dali::Toolkit::ProgressBar::New();
88725     } catch (std::out_of_range& e) {
88726       {
88727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88728       };
88729     } catch (std::exception& e) {
88730       {
88731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88732       };
88733     } catch (Dali::DaliException e) {
88734       {
88735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88736       };
88737     } catch (...) {
88738       {
88739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88740       };
88741     }
88742   }
88743
88744   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88745   return jresult;
88746 }
88747
88748
88749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88750   void * jresult ;
88751   Dali::Toolkit::ProgressBar *result = 0 ;
88752
88753   {
88754     try {
88755       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88756     } catch (std::out_of_range& e) {
88757       {
88758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88759       };
88760     } catch (std::exception& e) {
88761       {
88762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88763       };
88764     } catch (Dali::DaliException e) {
88765       {
88766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88767       };
88768     } catch (...) {
88769       {
88770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88771       };
88772     }
88773   }
88774
88775   jresult = (void *)result;
88776   return jresult;
88777 }
88778
88779
88780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88781   void * jresult ;
88782   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88783   Dali::Toolkit::ProgressBar *result = 0 ;
88784
88785   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88786   if (!arg1) {
88787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88788     return 0;
88789   }
88790   {
88791     try {
88792       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
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 = (void *)result;
88813   return jresult;
88814 }
88815
88816
88817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88818   void * jresult ;
88819   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88820   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88821   Dali::Toolkit::ProgressBar *result = 0 ;
88822
88823   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88824   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88825   if (!arg2) {
88826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88827     return 0;
88828   }
88829   {
88830     try {
88831       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88832     } catch (std::out_of_range& e) {
88833       {
88834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88835       };
88836     } catch (std::exception& e) {
88837       {
88838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88839       };
88840     } catch (Dali::DaliException e) {
88841       {
88842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88843       };
88844     } catch (...) {
88845       {
88846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88847       };
88848     }
88849   }
88850
88851   jresult = (void *)result;
88852   return jresult;
88853 }
88854
88855
88856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88857   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88858
88859   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88860   {
88861     try {
88862       delete arg1;
88863     } catch (std::out_of_range& e) {
88864       {
88865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88866       };
88867     } catch (std::exception& e) {
88868       {
88869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88870       };
88871     } catch (Dali::DaliException e) {
88872       {
88873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88874       };
88875     } catch (...) {
88876       {
88877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88878       };
88879     }
88880   }
88881
88882 }
88883
88884
88885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88886   void * jresult ;
88887   Dali::BaseHandle arg1 ;
88888   Dali::BaseHandle *argp1 ;
88889   Dali::Toolkit::ProgressBar result;
88890
88891   argp1 = (Dali::BaseHandle *)jarg1;
88892   if (!argp1) {
88893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88894     return 0;
88895   }
88896   arg1 = *argp1;
88897   {
88898     try {
88899       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88900     } catch (std::out_of_range& e) {
88901       {
88902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88903       };
88904     } catch (std::exception& e) {
88905       {
88906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88907       };
88908     } catch (Dali::DaliException e) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88911       };
88912     } catch (...) {
88913       {
88914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88915       };
88916     }
88917   }
88918
88919   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88920   return jresult;
88921 }
88922
88923
88924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88925   void * jresult ;
88926   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88927   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88928
88929   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88930   {
88931     try {
88932       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88933     } catch (std::out_of_range& e) {
88934       {
88935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88936       };
88937     } catch (std::exception& e) {
88938       {
88939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88940       };
88941     } catch (Dali::DaliException e) {
88942       {
88943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88944       };
88945     } catch (...) {
88946       {
88947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88948       };
88949     }
88950   }
88951
88952   jresult = (void *)result;
88953   return jresult;
88954 }
88955
88956
88957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88958   void * jresult ;
88959   Dali::Toolkit::GaussianBlurView *result = 0 ;
88960
88961   {
88962     try {
88963       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88964     } catch (std::out_of_range& e) {
88965       {
88966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88967       };
88968     } catch (std::exception& e) {
88969       {
88970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88971       };
88972     } catch (Dali::DaliException e) {
88973       {
88974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88975       };
88976     } catch (...) {
88977       {
88978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88979       };
88980     }
88981   }
88982
88983   jresult = (void *)result;
88984   return jresult;
88985 }
88986
88987
88988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88989   void * jresult ;
88990   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88991   Dali::Toolkit::GaussianBlurView *result = 0 ;
88992
88993   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88994   if (!arg1) {
88995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88996     return 0;
88997   }
88998   {
88999     try {
89000       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89001     } catch (std::out_of_range& e) {
89002       {
89003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89004       };
89005     } catch (std::exception& e) {
89006       {
89007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89008       };
89009     } catch (Dali::DaliException e) {
89010       {
89011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89012       };
89013     } catch (...) {
89014       {
89015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89016       };
89017     }
89018   }
89019
89020   jresult = (void *)result;
89021   return jresult;
89022 }
89023
89024
89025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89026   void * jresult ;
89027   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89028   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89029   Dali::Toolkit::GaussianBlurView *result = 0 ;
89030
89031   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89032   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89033   if (!arg2) {
89034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89035     return 0;
89036   }
89037   {
89038     try {
89039       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89040     } catch (std::out_of_range& e) {
89041       {
89042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89043       };
89044     } catch (std::exception& e) {
89045       {
89046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89047       };
89048     } catch (Dali::DaliException e) {
89049       {
89050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89051       };
89052     } catch (...) {
89053       {
89054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89055       };
89056     }
89057   }
89058
89059   jresult = (void *)result;
89060   return jresult;
89061 }
89062
89063
89064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89065   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89066
89067   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89068   {
89069     try {
89070       delete arg1;
89071     } catch (std::out_of_range& e) {
89072       {
89073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89074       };
89075     } catch (std::exception& e) {
89076       {
89077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89078       };
89079     } catch (Dali::DaliException e) {
89080       {
89081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89082       };
89083     } catch (...) {
89084       {
89085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89086       };
89087     }
89088   }
89089
89090 }
89091
89092
89093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89094   void * jresult ;
89095   Dali::BaseHandle arg1 ;
89096   Dali::BaseHandle *argp1 ;
89097   Dali::Toolkit::GaussianBlurView result;
89098
89099   argp1 = (Dali::BaseHandle *)jarg1;
89100   if (!argp1) {
89101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89102     return 0;
89103   }
89104   arg1 = *argp1;
89105   {
89106     try {
89107       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89108     } catch (std::out_of_range& e) {
89109       {
89110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89111       };
89112     } catch (std::exception& e) {
89113       {
89114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89115       };
89116     } catch (Dali::DaliException e) {
89117       {
89118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89119       };
89120     } catch (...) {
89121       {
89122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89123       };
89124     }
89125   }
89126
89127   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89128   return jresult;
89129 }
89130
89131
89132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89133   void * jresult ;
89134   Dali::Toolkit::GaussianBlurView result;
89135
89136   {
89137     try {
89138       result = Dali::Toolkit::GaussianBlurView::New();
89139     } catch (std::out_of_range& e) {
89140       {
89141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89142       };
89143     } catch (std::exception& e) {
89144       {
89145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89146       };
89147     } catch (Dali::DaliException e) {
89148       {
89149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89150       };
89151     } catch (...) {
89152       {
89153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89154       };
89155     }
89156   }
89157
89158   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89159   return jresult;
89160 }
89161
89162
89163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89164   void * jresult ;
89165   unsigned int arg1 ;
89166   float arg2 ;
89167   Dali::Pixel::Format arg3 ;
89168   float arg4 ;
89169   float arg5 ;
89170   bool arg6 ;
89171   Dali::Toolkit::GaussianBlurView result;
89172
89173   arg1 = (unsigned int)jarg1;
89174   arg2 = (float)jarg2;
89175   arg3 = (Dali::Pixel::Format)jarg3;
89176   arg4 = (float)jarg4;
89177   arg5 = (float)jarg5;
89178   arg6 = jarg6 ? true : false;
89179   {
89180     try {
89181       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89182     } catch (std::out_of_range& e) {
89183       {
89184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89185       };
89186     } catch (std::exception& e) {
89187       {
89188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89189       };
89190     } catch (Dali::DaliException e) {
89191       {
89192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89193       };
89194     } catch (...) {
89195       {
89196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89197       };
89198     }
89199   }
89200
89201   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89202   return jresult;
89203 }
89204
89205
89206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89207   void * jresult ;
89208   unsigned int arg1 ;
89209   float arg2 ;
89210   Dali::Pixel::Format arg3 ;
89211   float arg4 ;
89212   float arg5 ;
89213   Dali::Toolkit::GaussianBlurView result;
89214
89215   arg1 = (unsigned int)jarg1;
89216   arg2 = (float)jarg2;
89217   arg3 = (Dali::Pixel::Format)jarg3;
89218   arg4 = (float)jarg4;
89219   arg5 = (float)jarg5;
89220   {
89221     try {
89222       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89223     } catch (std::out_of_range& e) {
89224       {
89225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89226       };
89227     } catch (std::exception& e) {
89228       {
89229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89230       };
89231     } catch (Dali::DaliException e) {
89232       {
89233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89234       };
89235     } catch (...) {
89236       {
89237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89238       };
89239     }
89240   }
89241
89242   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89243   return jresult;
89244 }
89245
89246
89247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89248   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89249   Dali::Actor arg2 ;
89250   Dali::Actor *argp2 ;
89251
89252   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89253   argp2 = (Dali::Actor *)jarg2;
89254   if (!argp2) {
89255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89256     return ;
89257   }
89258   arg2 = *argp2;
89259   {
89260     try {
89261       (arg1)->Add(arg2);
89262     } catch (std::out_of_range& e) {
89263       {
89264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89265       };
89266     } catch (std::exception& e) {
89267       {
89268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89269       };
89270     } catch (Dali::DaliException e) {
89271       {
89272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89273       };
89274     } catch (...) {
89275       {
89276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89277       };
89278     }
89279   }
89280
89281 }
89282
89283
89284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89285   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89286   Dali::Actor arg2 ;
89287   Dali::Actor *argp2 ;
89288
89289   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89290   argp2 = (Dali::Actor *)jarg2;
89291   if (!argp2) {
89292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89293     return ;
89294   }
89295   arg2 = *argp2;
89296   {
89297     try {
89298       (arg1)->Remove(arg2);
89299     } catch (std::out_of_range& e) {
89300       {
89301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89302       };
89303     } catch (std::exception& e) {
89304       {
89305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89306       };
89307     } catch (Dali::DaliException e) {
89308       {
89309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89310       };
89311     } catch (...) {
89312       {
89313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89314       };
89315     }
89316   }
89317
89318 }
89319
89320
89321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89322   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89323
89324   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89325   {
89326     try {
89327       (arg1)->Activate();
89328     } catch (std::out_of_range& e) {
89329       {
89330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89331       };
89332     } catch (std::exception& e) {
89333       {
89334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89335       };
89336     } catch (Dali::DaliException e) {
89337       {
89338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89339       };
89340     } catch (...) {
89341       {
89342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89343       };
89344     }
89345   }
89346
89347 }
89348
89349
89350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89351   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89352
89353   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89354   {
89355     try {
89356       (arg1)->ActivateOnce();
89357     } catch (std::out_of_range& e) {
89358       {
89359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89360       };
89361     } catch (std::exception& e) {
89362       {
89363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89364       };
89365     } catch (Dali::DaliException e) {
89366       {
89367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89368       };
89369     } catch (...) {
89370       {
89371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89372       };
89373     }
89374   }
89375
89376 }
89377
89378
89379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89380   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89381
89382   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89383   {
89384     try {
89385       (arg1)->Deactivate();
89386     } catch (std::out_of_range& e) {
89387       {
89388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89389       };
89390     } catch (std::exception& e) {
89391       {
89392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89393       };
89394     } catch (Dali::DaliException e) {
89395       {
89396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89397       };
89398     } catch (...) {
89399       {
89400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89401       };
89402     }
89403   }
89404
89405 }
89406
89407
89408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89409   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89410   Dali::Image arg2 ;
89411   Dali::FrameBufferImage arg3 ;
89412   Dali::Image *argp2 ;
89413   Dali::FrameBufferImage *argp3 ;
89414
89415   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89416   argp2 = (Dali::Image *)jarg2;
89417   if (!argp2) {
89418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89419     return ;
89420   }
89421   arg2 = *argp2;
89422   argp3 = (Dali::FrameBufferImage *)jarg3;
89423   if (!argp3) {
89424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89425     return ;
89426   }
89427   arg3 = *argp3;
89428   {
89429     try {
89430       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89431     } catch (std::out_of_range& e) {
89432       {
89433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89434       };
89435     } catch (std::exception& e) {
89436       {
89437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89438       };
89439     } catch (Dali::DaliException e) {
89440       {
89441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89442       };
89443     } catch (...) {
89444       {
89445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89446       };
89447     }
89448   }
89449
89450 }
89451
89452
89453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89454   int jresult ;
89455   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89456   Dali::Property::Index result;
89457
89458   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89459   {
89460     try {
89461       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89462     } catch (std::out_of_range& e) {
89463       {
89464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89465       };
89466     } catch (std::exception& e) {
89467       {
89468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89469       };
89470     } catch (Dali::DaliException e) {
89471       {
89472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89473       };
89474     } catch (...) {
89475       {
89476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89477       };
89478     }
89479   }
89480
89481   jresult = result;
89482   return jresult;
89483 }
89484
89485
89486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89487   void * jresult ;
89488   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89489   Dali::FrameBufferImage result;
89490
89491   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89492   {
89493     try {
89494       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89495     } catch (std::out_of_range& e) {
89496       {
89497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89498       };
89499     } catch (std::exception& e) {
89500       {
89501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89502       };
89503     } catch (Dali::DaliException e) {
89504       {
89505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89506       };
89507     } catch (...) {
89508       {
89509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89510       };
89511     }
89512   }
89513
89514   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89515   return jresult;
89516 }
89517
89518
89519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89520   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89521   Dali::Vector4 *arg2 = 0 ;
89522
89523   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89524   arg2 = (Dali::Vector4 *)jarg2;
89525   if (!arg2) {
89526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89527     return ;
89528   }
89529   {
89530     try {
89531       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89532     } catch (std::out_of_range& e) {
89533       {
89534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89535       };
89536     } catch (std::exception& e) {
89537       {
89538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89539       };
89540     } catch (Dali::DaliException e) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89543       };
89544     } catch (...) {
89545       {
89546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89547       };
89548     }
89549   }
89550
89551 }
89552
89553
89554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89555   void * jresult ;
89556   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89557   Dali::Vector4 result;
89558
89559   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89560   {
89561     try {
89562       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89563     } catch (std::out_of_range& e) {
89564       {
89565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89566       };
89567     } catch (std::exception& e) {
89568       {
89569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89570       };
89571     } catch (Dali::DaliException e) {
89572       {
89573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89574       };
89575     } catch (...) {
89576       {
89577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89578       };
89579     }
89580   }
89581
89582   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89583   return jresult;
89584 }
89585
89586
89587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89588   void * jresult ;
89589   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89590   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89591
89592   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89593   {
89594     try {
89595       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89596     } catch (std::out_of_range& e) {
89597       {
89598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89599       };
89600     } catch (std::exception& e) {
89601       {
89602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89603       };
89604     } catch (Dali::DaliException e) {
89605       {
89606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89607       };
89608     } catch (...) {
89609       {
89610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89611       };
89612     }
89613   }
89614
89615   jresult = (void *)result;
89616   return jresult;
89617 }
89618
89619
89620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89621   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89622
89623   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89624   {
89625     try {
89626       delete arg1;
89627     } catch (std::out_of_range& e) {
89628       {
89629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89630       };
89631     } catch (std::exception& e) {
89632       {
89633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89634       };
89635     } catch (Dali::DaliException e) {
89636       {
89637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89638       };
89639     } catch (...) {
89640       {
89641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89642       };
89643     }
89644   }
89645
89646 }
89647
89648
89649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89650   unsigned int jresult ;
89651   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89652   unsigned int result;
89653
89654   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89655   {
89656     try {
89657       result = (unsigned int)(arg1)->GetNumberOfPages();
89658     } catch (std::out_of_range& e) {
89659       {
89660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89661       };
89662     } catch (std::exception& e) {
89663       {
89664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89665       };
89666     } catch (Dali::DaliException e) {
89667       {
89668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89669       };
89670     } catch (...) {
89671       {
89672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89673       };
89674     }
89675   }
89676
89677   jresult = result;
89678   return jresult;
89679 }
89680
89681
89682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89683   void * jresult ;
89684   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89685   unsigned int arg2 ;
89686   Dali::Texture result;
89687
89688   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89689   arg2 = (unsigned int)jarg2;
89690   {
89691     try {
89692       result = (arg1)->NewPage(arg2);
89693     } catch (std::out_of_range& e) {
89694       {
89695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89696       };
89697     } catch (std::exception& e) {
89698       {
89699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89700       };
89701     } catch (Dali::DaliException e) {
89702       {
89703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89704       };
89705     } catch (...) {
89706       {
89707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89708       };
89709     }
89710   }
89711
89712   jresult = new Dali::Texture((const Dali::Texture &)result);
89713   return jresult;
89714 }
89715
89716
89717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89718   int jresult ;
89719   int result;
89720
89721   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89722   jresult = (int)result;
89723   return jresult;
89724 }
89725
89726
89727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89728   int jresult ;
89729   int result;
89730
89731   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89732   jresult = (int)result;
89733   return jresult;
89734 }
89735
89736
89737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89738   int jresult ;
89739   int result;
89740
89741   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89742   jresult = (int)result;
89743   return jresult;
89744 }
89745
89746
89747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89748   void * jresult ;
89749   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89750
89751   {
89752     try {
89753       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89754     } catch (std::out_of_range& e) {
89755       {
89756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89757       };
89758     } catch (std::exception& e) {
89759       {
89760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89761       };
89762     } catch (Dali::DaliException e) {
89763       {
89764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89765       };
89766     } catch (...) {
89767       {
89768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89769       };
89770     }
89771   }
89772
89773   jresult = (void *)result;
89774   return jresult;
89775 }
89776
89777
89778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89779   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89780
89781   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89782   {
89783     try {
89784       delete arg1;
89785     } catch (std::out_of_range& e) {
89786       {
89787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89788       };
89789     } catch (std::exception& e) {
89790       {
89791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89792       };
89793     } catch (Dali::DaliException e) {
89794       {
89795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89796       };
89797     } catch (...) {
89798       {
89799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89800       };
89801     }
89802   }
89803
89804 }
89805
89806
89807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89808   void * jresult ;
89809   Dali::Toolkit::PageTurnView *result = 0 ;
89810
89811   {
89812     try {
89813       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89814     } catch (std::out_of_range& e) {
89815       {
89816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89817       };
89818     } catch (std::exception& e) {
89819       {
89820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89821       };
89822     } catch (Dali::DaliException e) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89825       };
89826     } catch (...) {
89827       {
89828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89829       };
89830     }
89831   }
89832
89833   jresult = (void *)result;
89834   return jresult;
89835 }
89836
89837
89838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89839   void * jresult ;
89840   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89841   Dali::Toolkit::PageTurnView *result = 0 ;
89842
89843   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89844   if (!arg1) {
89845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89846     return 0;
89847   }
89848   {
89849     try {
89850       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89851     } catch (std::out_of_range& e) {
89852       {
89853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89854       };
89855     } catch (std::exception& e) {
89856       {
89857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89858       };
89859     } catch (Dali::DaliException e) {
89860       {
89861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89862       };
89863     } catch (...) {
89864       {
89865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89866       };
89867     }
89868   }
89869
89870   jresult = (void *)result;
89871   return jresult;
89872 }
89873
89874
89875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89876   void * jresult ;
89877   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89878   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89879   Dali::Toolkit::PageTurnView *result = 0 ;
89880
89881   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89882   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89883   if (!arg2) {
89884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89885     return 0;
89886   }
89887   {
89888     try {
89889       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89890     } catch (std::out_of_range& e) {
89891       {
89892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89893       };
89894     } catch (std::exception& e) {
89895       {
89896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89897       };
89898     } catch (Dali::DaliException e) {
89899       {
89900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89901       };
89902     } catch (...) {
89903       {
89904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89905       };
89906     }
89907   }
89908
89909   jresult = (void *)result;
89910   return jresult;
89911 }
89912
89913
89914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89915   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89916
89917   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89918   {
89919     try {
89920       delete arg1;
89921     } catch (std::out_of_range& e) {
89922       {
89923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89924       };
89925     } catch (std::exception& e) {
89926       {
89927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89928       };
89929     } catch (Dali::DaliException e) {
89930       {
89931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89932       };
89933     } catch (...) {
89934       {
89935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89936       };
89937     }
89938   }
89939
89940 }
89941
89942
89943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89944   void * jresult ;
89945   Dali::BaseHandle arg1 ;
89946   Dali::BaseHandle *argp1 ;
89947   Dali::Toolkit::PageTurnView result;
89948
89949   argp1 = (Dali::BaseHandle *)jarg1;
89950   if (!argp1) {
89951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89952     return 0;
89953   }
89954   arg1 = *argp1;
89955   {
89956     try {
89957       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89958     } catch (std::out_of_range& e) {
89959       {
89960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89961       };
89962     } catch (std::exception& e) {
89963       {
89964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89965       };
89966     } catch (Dali::DaliException e) {
89967       {
89968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89969       };
89970     } catch (...) {
89971       {
89972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89973       };
89974     }
89975   }
89976
89977   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89978   return jresult;
89979 }
89980
89981
89982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89983   void * jresult ;
89984   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89985   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89986
89987   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89988   {
89989     try {
89990       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89991     } catch (std::out_of_range& e) {
89992       {
89993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89994       };
89995     } catch (std::exception& e) {
89996       {
89997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89998       };
89999     } catch (Dali::DaliException e) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90002       };
90003     } catch (...) {
90004       {
90005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90006       };
90007     }
90008   }
90009
90010   jresult = (void *)result;
90011   return jresult;
90012 }
90013
90014
90015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90016   void * jresult ;
90017   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90018   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90019
90020   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90021   {
90022     try {
90023       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90024     } catch (std::out_of_range& e) {
90025       {
90026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90027       };
90028     } catch (std::exception& e) {
90029       {
90030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90031       };
90032     } catch (Dali::DaliException e) {
90033       {
90034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90035       };
90036     } catch (...) {
90037       {
90038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90039       };
90040     }
90041   }
90042
90043   jresult = (void *)result;
90044   return jresult;
90045 }
90046
90047
90048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90049   void * jresult ;
90050   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90051   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90052
90053   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90054   {
90055     try {
90056       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90057     } catch (std::out_of_range& e) {
90058       {
90059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90060       };
90061     } catch (std::exception& e) {
90062       {
90063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90064       };
90065     } catch (Dali::DaliException e) {
90066       {
90067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90068       };
90069     } catch (...) {
90070       {
90071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90072       };
90073     }
90074   }
90075
90076   jresult = (void *)result;
90077   return jresult;
90078 }
90079
90080
90081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90082   void * jresult ;
90083   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90084   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90085
90086   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90087   {
90088     try {
90089       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90090     } catch (std::out_of_range& e) {
90091       {
90092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90093       };
90094     } catch (std::exception& e) {
90095       {
90096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90097       };
90098     } catch (Dali::DaliException e) {
90099       {
90100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90101       };
90102     } catch (...) {
90103       {
90104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90105       };
90106     }
90107   }
90108
90109   jresult = (void *)result;
90110   return jresult;
90111 }
90112
90113
90114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90115   void * jresult ;
90116   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90117
90118   {
90119     try {
90120       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90121     } catch (std::out_of_range& e) {
90122       {
90123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90124       };
90125     } catch (std::exception& e) {
90126       {
90127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90128       };
90129     } catch (Dali::DaliException e) {
90130       {
90131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90132       };
90133     } catch (...) {
90134       {
90135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90136       };
90137     }
90138   }
90139
90140   jresult = (void *)result;
90141   return jresult;
90142 }
90143
90144
90145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90146   void * jresult ;
90147   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90148   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90149
90150   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90151   if (!arg1) {
90152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90153     return 0;
90154   }
90155   {
90156     try {
90157       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90165       };
90166     } catch (Dali::DaliException e) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90169       };
90170     } catch (...) {
90171       {
90172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90173       };
90174     }
90175   }
90176
90177   jresult = (void *)result;
90178   return jresult;
90179 }
90180
90181
90182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90183   void * jresult ;
90184   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90185   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90186   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90187
90188   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90189   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90190   if (!arg2) {
90191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90192     return 0;
90193   }
90194   {
90195     try {
90196       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90197     } catch (std::out_of_range& e) {
90198       {
90199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90200       };
90201     } catch (std::exception& e) {
90202       {
90203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90204       };
90205     } catch (Dali::DaliException e) {
90206       {
90207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90208       };
90209     } catch (...) {
90210       {
90211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90212       };
90213     }
90214   }
90215
90216   jresult = (void *)result;
90217   return jresult;
90218 }
90219
90220
90221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90222   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90223
90224   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90225   {
90226     try {
90227       delete arg1;
90228     } catch (std::out_of_range& e) {
90229       {
90230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90231       };
90232     } catch (std::exception& e) {
90233       {
90234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90235       };
90236     } catch (Dali::DaliException e) {
90237       {
90238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90239       };
90240     } catch (...) {
90241       {
90242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90243       };
90244     }
90245   }
90246
90247 }
90248
90249
90250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90251   void * jresult ;
90252   Dali::Toolkit::PageFactory *arg1 = 0 ;
90253   Dali::Vector2 *arg2 = 0 ;
90254   Dali::Toolkit::PageTurnLandscapeView result;
90255
90256   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90257   if (!arg1) {
90258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90259     return 0;
90260   }
90261   arg2 = (Dali::Vector2 *)jarg2;
90262   if (!arg2) {
90263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90264     return 0;
90265   }
90266   {
90267     try {
90268       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90269     } catch (std::out_of_range& e) {
90270       {
90271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90272       };
90273     } catch (std::exception& e) {
90274       {
90275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90276       };
90277     } catch (Dali::DaliException e) {
90278       {
90279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90280       };
90281     } catch (...) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90284       };
90285     }
90286   }
90287
90288   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90289   return jresult;
90290 }
90291
90292
90293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90294   void * jresult ;
90295   Dali::BaseHandle arg1 ;
90296   Dali::BaseHandle *argp1 ;
90297   Dali::Toolkit::PageTurnLandscapeView result;
90298
90299   argp1 = (Dali::BaseHandle *)jarg1;
90300   if (!argp1) {
90301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90302     return 0;
90303   }
90304   arg1 = *argp1;
90305   {
90306     try {
90307       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90308     } catch (std::out_of_range& e) {
90309       {
90310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90311       };
90312     } catch (std::exception& e) {
90313       {
90314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90315       };
90316     } catch (Dali::DaliException e) {
90317       {
90318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90319       };
90320     } catch (...) {
90321       {
90322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90323       };
90324     }
90325   }
90326
90327   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90328   return jresult;
90329 }
90330
90331
90332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90333   void * jresult ;
90334   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90335
90336   {
90337     try {
90338       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90339     } catch (std::out_of_range& e) {
90340       {
90341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90342       };
90343     } catch (std::exception& e) {
90344       {
90345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90346       };
90347     } catch (Dali::DaliException e) {
90348       {
90349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90350       };
90351     } catch (...) {
90352       {
90353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90354       };
90355     }
90356   }
90357
90358   jresult = (void *)result;
90359   return jresult;
90360 }
90361
90362
90363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90364   void * jresult ;
90365   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90366   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90367
90368   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90369   if (!arg1) {
90370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90371     return 0;
90372   }
90373   {
90374     try {
90375       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90376     } catch (std::out_of_range& e) {
90377       {
90378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90379       };
90380     } catch (std::exception& e) {
90381       {
90382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90383       };
90384     } catch (Dali::DaliException e) {
90385       {
90386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90387       };
90388     } catch (...) {
90389       {
90390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90391       };
90392     }
90393   }
90394
90395   jresult = (void *)result;
90396   return jresult;
90397 }
90398
90399
90400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90401   void * jresult ;
90402   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90403   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90404   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90405
90406   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90407   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90408   if (!arg2) {
90409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90410     return 0;
90411   }
90412   {
90413     try {
90414       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90415     } catch (std::out_of_range& e) {
90416       {
90417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90418       };
90419     } catch (std::exception& e) {
90420       {
90421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90422       };
90423     } catch (Dali::DaliException e) {
90424       {
90425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90426       };
90427     } catch (...) {
90428       {
90429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90430       };
90431     }
90432   }
90433
90434   jresult = (void *)result;
90435   return jresult;
90436 }
90437
90438
90439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90440   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90441
90442   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90443   {
90444     try {
90445       delete arg1;
90446     } catch (std::out_of_range& e) {
90447       {
90448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90449       };
90450     } catch (std::exception& e) {
90451       {
90452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90453       };
90454     } catch (Dali::DaliException e) {
90455       {
90456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90457       };
90458     } catch (...) {
90459       {
90460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90461       };
90462     }
90463   }
90464
90465 }
90466
90467
90468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90469   void * jresult ;
90470   Dali::Toolkit::PageFactory *arg1 = 0 ;
90471   Dali::Vector2 *arg2 = 0 ;
90472   Dali::Toolkit::PageTurnPortraitView result;
90473
90474   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90475   if (!arg1) {
90476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90477     return 0;
90478   }
90479   arg2 = (Dali::Vector2 *)jarg2;
90480   if (!arg2) {
90481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90482     return 0;
90483   }
90484   {
90485     try {
90486       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90487     } catch (std::out_of_range& e) {
90488       {
90489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90490       };
90491     } catch (std::exception& e) {
90492       {
90493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90494       };
90495     } catch (Dali::DaliException e) {
90496       {
90497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90498       };
90499     } catch (...) {
90500       {
90501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90502       };
90503     }
90504   }
90505
90506   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90507   return jresult;
90508 }
90509
90510
90511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90512   void * jresult ;
90513   Dali::BaseHandle arg1 ;
90514   Dali::BaseHandle *argp1 ;
90515   Dali::Toolkit::PageTurnPortraitView result;
90516
90517   argp1 = (Dali::BaseHandle *)jarg1;
90518   if (!argp1) {
90519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90520     return 0;
90521   }
90522   arg1 = *argp1;
90523   {
90524     try {
90525       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90526     } catch (std::out_of_range& e) {
90527       {
90528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90529       };
90530     } catch (std::exception& e) {
90531       {
90532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90533       };
90534     } catch (Dali::DaliException e) {
90535       {
90536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90537       };
90538     } catch (...) {
90539       {
90540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90541       };
90542     }
90543   }
90544
90545   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90546   return jresult;
90547 }
90548
90549
90550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90551   int jresult ;
90552   int result;
90553
90554   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90555   jresult = (int)result;
90556   return jresult;
90557 }
90558
90559
90560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90561   int jresult ;
90562   int result;
90563
90564   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90565   jresult = (int)result;
90566   return jresult;
90567 }
90568
90569
90570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90571   int jresult ;
90572   int result;
90573
90574   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90575   jresult = (int)result;
90576   return jresult;
90577 }
90578
90579
90580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90581   void * jresult ;
90582   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90583
90584   {
90585     try {
90586       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90587     } catch (std::out_of_range& e) {
90588       {
90589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90590       };
90591     } catch (std::exception& e) {
90592       {
90593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90594       };
90595     } catch (Dali::DaliException e) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90598       };
90599     } catch (...) {
90600       {
90601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90602       };
90603     }
90604   }
90605
90606   jresult = (void *)result;
90607   return jresult;
90608 }
90609
90610
90611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90612   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90613
90614   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90615   {
90616     try {
90617       delete arg1;
90618     } catch (std::out_of_range& e) {
90619       {
90620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90621       };
90622     } catch (std::exception& e) {
90623       {
90624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90625       };
90626     } catch (Dali::DaliException e) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90629       };
90630     } catch (...) {
90631       {
90632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90633       };
90634     }
90635   }
90636
90637 }
90638
90639
90640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90641   void * jresult ;
90642   Dali::Toolkit::ToggleButton *result = 0 ;
90643
90644   {
90645     try {
90646       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90647     } catch (std::out_of_range& e) {
90648       {
90649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90650       };
90651     } catch (std::exception& e) {
90652       {
90653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90654       };
90655     } catch (Dali::DaliException e) {
90656       {
90657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90658       };
90659     } catch (...) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90662       };
90663     }
90664   }
90665
90666   jresult = (void *)result;
90667   return jresult;
90668 }
90669
90670
90671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90672   void * jresult ;
90673   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90674   Dali::Toolkit::ToggleButton *result = 0 ;
90675
90676   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90677   if (!arg1) {
90678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90679     return 0;
90680   }
90681   {
90682     try {
90683       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90684     } catch (std::out_of_range& e) {
90685       {
90686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90687       };
90688     } catch (std::exception& e) {
90689       {
90690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90691       };
90692     } catch (Dali::DaliException e) {
90693       {
90694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90695       };
90696     } catch (...) {
90697       {
90698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90699       };
90700     }
90701   }
90702
90703   jresult = (void *)result;
90704   return jresult;
90705 }
90706
90707
90708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90709   void * jresult ;
90710   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90711   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90712   Dali::Toolkit::ToggleButton *result = 0 ;
90713
90714   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90715   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90716   if (!arg2) {
90717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90718     return 0;
90719   }
90720   {
90721     try {
90722       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90723     } catch (std::out_of_range& e) {
90724       {
90725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90726       };
90727     } catch (std::exception& e) {
90728       {
90729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90730       };
90731     } catch (Dali::DaliException e) {
90732       {
90733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90734       };
90735     } catch (...) {
90736       {
90737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90738       };
90739     }
90740   }
90741
90742   jresult = (void *)result;
90743   return jresult;
90744 }
90745
90746
90747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90748   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90749
90750   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90751   {
90752     try {
90753       delete arg1;
90754     } catch (std::out_of_range& e) {
90755       {
90756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90757       };
90758     } catch (std::exception& e) {
90759       {
90760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90761       };
90762     } catch (Dali::DaliException e) {
90763       {
90764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90765       };
90766     } catch (...) {
90767       {
90768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90769       };
90770     }
90771   }
90772
90773 }
90774
90775
90776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90777   void * jresult ;
90778   Dali::Toolkit::ToggleButton result;
90779
90780   {
90781     try {
90782       result = Dali::Toolkit::ToggleButton::New();
90783     } catch (std::out_of_range& e) {
90784       {
90785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90786       };
90787     } catch (std::exception& e) {
90788       {
90789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90790       };
90791     } catch (Dali::DaliException e) {
90792       {
90793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90794       };
90795     } catch (...) {
90796       {
90797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90798       };
90799     }
90800   }
90801
90802   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90803   return jresult;
90804 }
90805
90806
90807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90808   void * jresult ;
90809   Dali::BaseHandle arg1 ;
90810   Dali::BaseHandle *argp1 ;
90811   Dali::Toolkit::ToggleButton result;
90812
90813   argp1 = (Dali::BaseHandle *)jarg1;
90814   if (!argp1) {
90815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90816     return 0;
90817   }
90818   arg1 = *argp1;
90819   {
90820     try {
90821       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90822     } catch (std::out_of_range& e) {
90823       {
90824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90825       };
90826     } catch (std::exception& e) {
90827       {
90828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90829       };
90830     } catch (Dali::DaliException e) {
90831       {
90832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90833       };
90834     } catch (...) {
90835       {
90836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90837       };
90838     }
90839   }
90840
90841   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90842   return jresult;
90843 }
90844
90845
90846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90847   void * jresult ;
90848   Dali::Toolkit::Visual::Base *result = 0 ;
90849
90850   {
90851     try {
90852       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90853     } catch (std::out_of_range& e) {
90854       {
90855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90856       };
90857     } catch (std::exception& e) {
90858       {
90859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90860       };
90861     } catch (Dali::DaliException e) {
90862       {
90863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90864       };
90865     } catch (...) {
90866       {
90867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90868       };
90869     }
90870   }
90871
90872   jresult = (void *)result;
90873   return jresult;
90874 }
90875
90876
90877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90878   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90879
90880   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90881   {
90882     try {
90883       delete arg1;
90884     } catch (std::out_of_range& e) {
90885       {
90886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90887       };
90888     } catch (std::exception& e) {
90889       {
90890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90891       };
90892     } catch (Dali::DaliException e) {
90893       {
90894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90895       };
90896     } catch (...) {
90897       {
90898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90899       };
90900     }
90901   }
90902
90903 }
90904
90905
90906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90907   void * jresult ;
90908   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90909   Dali::Toolkit::Visual::Base *result = 0 ;
90910
90911   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90912   if (!arg1) {
90913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90914     return 0;
90915   }
90916   {
90917     try {
90918       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90919     } catch (std::out_of_range& e) {
90920       {
90921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90922       };
90923     } catch (std::exception& e) {
90924       {
90925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90926       };
90927     } catch (Dali::DaliException e) {
90928       {
90929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90930       };
90931     } catch (...) {
90932       {
90933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90934       };
90935     }
90936   }
90937
90938   jresult = (void *)result;
90939   return jresult;
90940 }
90941
90942
90943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90944   void * jresult ;
90945   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90946   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90947   Dali::Toolkit::Visual::Base *result = 0 ;
90948
90949   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90950   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90951   if (!arg2) {
90952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90953     return 0;
90954   }
90955   {
90956     try {
90957       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90958     } catch (std::out_of_range& e) {
90959       {
90960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90961       };
90962     } catch (std::exception& e) {
90963       {
90964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90965       };
90966     } catch (Dali::DaliException e) {
90967       {
90968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90969       };
90970     } catch (...) {
90971       {
90972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90973       };
90974     }
90975   }
90976
90977   jresult = (void *)result;
90978   return jresult;
90979 }
90980
90981
90982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90983   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90984   std::string *arg2 = 0 ;
90985
90986   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90987   if (!jarg2) {
90988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90989     return ;
90990   }
90991   std::string arg2_str(jarg2);
90992   arg2 = &arg2_str;
90993   {
90994     try {
90995       (arg1)->SetName((std::string const &)*arg2);
90996     } catch (std::out_of_range& e) {
90997       {
90998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90999       };
91000     } catch (std::exception& e) {
91001       {
91002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91003       };
91004     } catch (Dali::DaliException e) {
91005       {
91006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91007       };
91008     } catch (...) {
91009       {
91010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91011       };
91012     }
91013   }
91014
91015
91016   //argout typemap for const std::string&
91017
91018 }
91019
91020
91021 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91022   char * jresult ;
91023   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91024   std::string *result = 0 ;
91025
91026   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91027   {
91028     try {
91029       result = (std::string *) &(arg1)->GetName();
91030     } catch (std::out_of_range& e) {
91031       {
91032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91033       };
91034     } catch (std::exception& e) {
91035       {
91036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91037       };
91038     } catch (Dali::DaliException e) {
91039       {
91040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91041       };
91042     } catch (...) {
91043       {
91044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91045       };
91046     }
91047   }
91048
91049   jresult = SWIG_csharp_string_callback(result->c_str());
91050   return jresult;
91051 }
91052
91053
91054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91055   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91056   Dali::Property::Map *arg2 = 0 ;
91057   Dali::Size arg3 ;
91058   Dali::Size *argp3 ;
91059
91060   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91061   arg2 = (Dali::Property::Map *)jarg2;
91062   if (!arg2) {
91063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91064     return ;
91065   }
91066   argp3 = (Dali::Size *)jarg3;
91067   if (!argp3) {
91068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91069     return ;
91070   }
91071   arg3 = *argp3;
91072   {
91073     try {
91074       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91075     } catch (std::out_of_range& e) {
91076       {
91077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91078       };
91079     } catch (std::exception& e) {
91080       {
91081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91082       };
91083     } catch (Dali::DaliException e) {
91084       {
91085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91086       };
91087     } catch (...) {
91088       {
91089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91090       };
91091     }
91092   }
91093
91094 }
91095
91096
91097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91098   float jresult ;
91099   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91100   float arg2 ;
91101   float result;
91102
91103   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91104   arg2 = (float)jarg2;
91105   {
91106     try {
91107       result = (float)(arg1)->GetHeightForWidth(arg2);
91108     } catch (std::out_of_range& e) {
91109       {
91110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91111       };
91112     } catch (std::exception& e) {
91113       {
91114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91115       };
91116     } catch (Dali::DaliException e) {
91117       {
91118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91119       };
91120     } catch (...) {
91121       {
91122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91123       };
91124     }
91125   }
91126
91127   jresult = result;
91128   return jresult;
91129 }
91130
91131
91132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91133   float jresult ;
91134   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91135   float arg2 ;
91136   float result;
91137
91138   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91139   arg2 = (float)jarg2;
91140   {
91141     try {
91142       result = (float)(arg1)->GetWidthForHeight(arg2);
91143     } catch (std::out_of_range& e) {
91144       {
91145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91146       };
91147     } catch (std::exception& e) {
91148       {
91149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91150       };
91151     } catch (Dali::DaliException e) {
91152       {
91153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91154       };
91155     } catch (...) {
91156       {
91157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91158       };
91159     }
91160   }
91161
91162   jresult = result;
91163   return jresult;
91164 }
91165
91166
91167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91168   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91169   Dali::Vector2 *arg2 = 0 ;
91170
91171   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91172   arg2 = (Dali::Vector2 *)jarg2;
91173   if (!arg2) {
91174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91175     return ;
91176   }
91177   {
91178     try {
91179       (arg1)->GetNaturalSize(*arg2);
91180     } catch (std::out_of_range& e) {
91181       {
91182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91183       };
91184     } catch (std::exception& e) {
91185       {
91186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91187       };
91188     } catch (Dali::DaliException e) {
91189       {
91190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91191       };
91192     } catch (...) {
91193       {
91194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91195       };
91196     }
91197   }
91198
91199 }
91200
91201
91202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91203   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91204   float arg2 ;
91205
91206   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91207   arg2 = (int)jarg2;
91208   {
91209     try {
91210       (arg1)->SetDepthIndex(arg2);
91211     } catch (std::out_of_range& e) {
91212       {
91213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91214       };
91215     } catch (std::exception& e) {
91216       {
91217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91218       };
91219     } catch (Dali::DaliException e) {
91220       {
91221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91222       };
91223     } catch (...) {
91224       {
91225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91226       };
91227     }
91228   }
91229
91230 }
91231
91232
91233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91234   int jresult ;
91235   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91236   int result;
91237
91238   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91239   {
91240     try {
91241       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91242     } catch (std::out_of_range& e) {
91243       {
91244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91245       };
91246     } catch (std::exception& e) {
91247       {
91248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91249       };
91250     } catch (Dali::DaliException e) {
91251       {
91252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91253       };
91254     } catch (...) {
91255       {
91256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91257       };
91258     }
91259   }
91260
91261   jresult = result;
91262   return jresult;
91263 }
91264
91265
91266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91267   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91268   Dali::Property::Map *arg2 = 0 ;
91269
91270   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91271   arg2 = (Dali::Property::Map *)jarg2;
91272   if (!arg2) {
91273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91274     return ;
91275   }
91276   {
91277     try {
91278       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91279     } catch (std::out_of_range& e) {
91280       {
91281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91282       };
91283     } catch (std::exception& e) {
91284       {
91285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91286       };
91287     } catch (Dali::DaliException e) {
91288       {
91289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91290       };
91291     } catch (...) {
91292       {
91293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91294       };
91295     }
91296   }
91297
91298 }
91299
91300
91301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91302   void * jresult ;
91303   Dali::Toolkit::VisualFactory result;
91304
91305   {
91306     try {
91307       result = Dali::Toolkit::VisualFactory::Get();
91308     } catch (std::out_of_range& e) {
91309       {
91310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91311       };
91312     } catch (std::exception& e) {
91313       {
91314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91315       };
91316     } catch (Dali::DaliException e) {
91317       {
91318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91319       };
91320     } catch (...) {
91321       {
91322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91323       };
91324     }
91325   }
91326
91327   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91328   return jresult;
91329 }
91330
91331
91332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91333   void * jresult ;
91334   Dali::Toolkit::VisualFactory *result = 0 ;
91335
91336   {
91337     try {
91338       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91339     } catch (std::out_of_range& e) {
91340       {
91341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91342       };
91343     } catch (std::exception& e) {
91344       {
91345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91346       };
91347     } catch (Dali::DaliException e) {
91348       {
91349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91350       };
91351     } catch (...) {
91352       {
91353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91354       };
91355     }
91356   }
91357
91358   jresult = (void *)result;
91359   return jresult;
91360 }
91361
91362
91363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91364   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91365
91366   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91367   {
91368     try {
91369       delete arg1;
91370     } catch (std::out_of_range& e) {
91371       {
91372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91373       };
91374     } catch (std::exception& e) {
91375       {
91376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91377       };
91378     } catch (Dali::DaliException e) {
91379       {
91380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91381       };
91382     } catch (...) {
91383       {
91384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91385       };
91386     }
91387   }
91388
91389 }
91390
91391
91392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91393   void * jresult ;
91394   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91395   Dali::Toolkit::VisualFactory *result = 0 ;
91396
91397   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91398   if (!arg1) {
91399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91400     return 0;
91401   }
91402   {
91403     try {
91404       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91405     } catch (std::out_of_range& e) {
91406       {
91407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91408       };
91409     } catch (std::exception& e) {
91410       {
91411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91412       };
91413     } catch (Dali::DaliException e) {
91414       {
91415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91416       };
91417     } catch (...) {
91418       {
91419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91420       };
91421     }
91422   }
91423
91424   jresult = (void *)result;
91425   return jresult;
91426 }
91427
91428
91429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91430   void * jresult ;
91431   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91432   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91433   Dali::Toolkit::VisualFactory *result = 0 ;
91434
91435   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91436   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91437   if (!arg2) {
91438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91439     return 0;
91440   }
91441   {
91442     try {
91443       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91444     } catch (std::out_of_range& e) {
91445       {
91446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91447       };
91448     } catch (std::exception& e) {
91449       {
91450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91451       };
91452     } catch (Dali::DaliException e) {
91453       {
91454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91455       };
91456     } catch (...) {
91457       {
91458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91459       };
91460     }
91461   }
91462
91463   jresult = (void *)result;
91464   return jresult;
91465 }
91466
91467
91468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91469   void * jresult ;
91470   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91471   Dali::Property::Map *arg2 = 0 ;
91472   Dali::Toolkit::Visual::Base result;
91473
91474   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91475   arg2 = (Dali::Property::Map *)jarg2;
91476   if (!arg2) {
91477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91478     return 0;
91479   }
91480   {
91481     try {
91482       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91483     } catch (std::out_of_range& e) {
91484       {
91485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91486       };
91487     } catch (std::exception& e) {
91488       {
91489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91490       };
91491     } catch (Dali::DaliException e) {
91492       {
91493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91494       };
91495     } catch (...) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91498       };
91499     }
91500   }
91501
91502   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91503   return jresult;
91504 }
91505
91506
91507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91508   void * jresult ;
91509   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91510   Dali::Image *arg2 = 0 ;
91511   Dali::Toolkit::Visual::Base result;
91512
91513   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91514   arg2 = (Dali::Image *)jarg2;
91515   if (!arg2) {
91516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91517     return 0;
91518   }
91519   {
91520     try {
91521       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91529       };
91530     } catch (Dali::DaliException e) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91533       };
91534     } catch (...) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91537       };
91538     }
91539   }
91540
91541   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91542   return jresult;
91543 }
91544
91545
91546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91547   void * jresult ;
91548   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91549   std::string *arg2 = 0 ;
91550   Dali::ImageDimensions arg3 ;
91551   Dali::ImageDimensions *argp3 ;
91552   Dali::Toolkit::Visual::Base result;
91553
91554   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91555   if (!jarg2) {
91556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91557     return 0;
91558   }
91559   std::string arg2_str(jarg2);
91560   arg2 = &arg2_str;
91561   argp3 = (Dali::ImageDimensions *)jarg3;
91562   if (!argp3) {
91563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91564     return 0;
91565   }
91566   arg3 = *argp3;
91567   {
91568     try {
91569       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91570     } catch (std::out_of_range& e) {
91571       {
91572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91573       };
91574     } catch (std::exception& e) {
91575       {
91576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91577       };
91578     } catch (Dali::DaliException e) {
91579       {
91580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91581       };
91582     } catch (...) {
91583       {
91584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91585       };
91586     }
91587   }
91588
91589   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91590
91591   //argout typemap for const std::string&
91592
91593   return jresult;
91594 }
91595
91596
91597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91598   void * jresult ;
91599   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91600
91601   {
91602     try {
91603       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91604     } catch (std::out_of_range& e) {
91605       {
91606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91607       };
91608     } catch (std::exception& e) {
91609       {
91610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91611       };
91612     } catch (Dali::DaliException e) {
91613       {
91614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91615       };
91616     } catch (...) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91619       };
91620     }
91621   }
91622
91623   jresult = (void *)result;
91624   return jresult;
91625 }
91626
91627
91628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91629   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91630
91631   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91632   {
91633     try {
91634       delete arg1;
91635     } catch (std::out_of_range& e) {
91636       {
91637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91638       };
91639     } catch (std::exception& e) {
91640       {
91641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91642       };
91643     } catch (Dali::DaliException e) {
91644       {
91645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91646       };
91647     } catch (...) {
91648       {
91649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91650       };
91651     }
91652   }
91653
91654 }
91655
91656
91657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91658   void * jresult ;
91659   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91660   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91661
91662   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91663   if (!arg1) {
91664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91665     return 0;
91666   }
91667   {
91668     try {
91669       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91670     } catch (std::out_of_range& e) {
91671       {
91672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91673       };
91674     } catch (std::exception& e) {
91675       {
91676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91677       };
91678     } catch (Dali::DaliException e) {
91679       {
91680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91681       };
91682     } catch (...) {
91683       {
91684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91685       };
91686     }
91687   }
91688
91689   jresult = (void *)result;
91690   return jresult;
91691 }
91692
91693
91694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91695   void * jresult ;
91696   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91697   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91698   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91699
91700   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91701   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91702   if (!arg2) {
91703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91704     return 0;
91705   }
91706   {
91707     try {
91708       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91709     } catch (std::out_of_range& e) {
91710       {
91711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91712       };
91713     } catch (std::exception& e) {
91714       {
91715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91716       };
91717     } catch (Dali::DaliException e) {
91718       {
91719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91720       };
91721     } catch (...) {
91722       {
91723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91724       };
91725     }
91726   }
91727
91728   jresult = (void *)result;
91729   return jresult;
91730 }
91731
91732
91733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91734   void * jresult ;
91735   Dali::Toolkit::AsyncImageLoader result;
91736
91737   {
91738     try {
91739       result = Dali::Toolkit::AsyncImageLoader::New();
91740     } catch (std::out_of_range& e) {
91741       {
91742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91743       };
91744     } catch (std::exception& e) {
91745       {
91746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91747       };
91748     } catch (Dali::DaliException e) {
91749       {
91750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91751       };
91752     } catch (...) {
91753       {
91754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91755       };
91756     }
91757   }
91758
91759   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91760   return jresult;
91761 }
91762
91763
91764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91765   void * jresult ;
91766   Dali::BaseHandle arg1 ;
91767   Dali::BaseHandle *argp1 ;
91768   Dali::Toolkit::AsyncImageLoader result;
91769
91770   argp1 = (Dali::BaseHandle *)jarg1;
91771   if (!argp1) {
91772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91773     return 0;
91774   }
91775   arg1 = *argp1;
91776   {
91777     try {
91778       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91779     } catch (std::out_of_range& e) {
91780       {
91781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91782       };
91783     } catch (std::exception& e) {
91784       {
91785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91786       };
91787     } catch (Dali::DaliException e) {
91788       {
91789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91790       };
91791     } catch (...) {
91792       {
91793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91794       };
91795     }
91796   }
91797
91798   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91799   return jresult;
91800 }
91801
91802
91803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91804   unsigned int jresult ;
91805   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91806   std::string *arg2 = 0 ;
91807   uint32_t result;
91808
91809   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91810   if (!jarg2) {
91811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91812     return 0;
91813   }
91814   std::string arg2_str(jarg2);
91815   arg2 = &arg2_str;
91816   {
91817     try {
91818       result = (arg1)->Load((std::string const &)*arg2);
91819     } catch (std::out_of_range& e) {
91820       {
91821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91822       };
91823     } catch (std::exception& e) {
91824       {
91825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91826       };
91827     } catch (Dali::DaliException e) {
91828       {
91829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91830       };
91831     } catch (...) {
91832       {
91833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91834       };
91835     }
91836   }
91837
91838   jresult = result;
91839
91840   //argout typemap for const std::string&
91841
91842   return jresult;
91843 }
91844
91845
91846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91847   unsigned int jresult ;
91848   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91849   std::string *arg2 = 0 ;
91850   Dali::ImageDimensions arg3 ;
91851   Dali::ImageDimensions *argp3 ;
91852   uint32_t result;
91853
91854   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91855   if (!jarg2) {
91856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91857     return 0;
91858   }
91859   std::string arg2_str(jarg2);
91860   arg2 = &arg2_str;
91861   argp3 = (Dali::ImageDimensions *)jarg3;
91862   if (!argp3) {
91863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91864     return 0;
91865   }
91866   arg3 = *argp3;
91867   {
91868     try {
91869       result = (arg1)->Load((std::string const &)*arg2,arg3);
91870     } catch (std::out_of_range& e) {
91871       {
91872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91873       };
91874     } catch (std::exception& e) {
91875       {
91876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91877       };
91878     } catch (Dali::DaliException e) {
91879       {
91880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91881       };
91882     } catch (...) {
91883       {
91884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91885       };
91886     }
91887   }
91888
91889   jresult = result;
91890
91891   //argout typemap for const std::string&
91892
91893   return jresult;
91894 }
91895
91896
91897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91898   unsigned int jresult ;
91899   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91900   std::string *arg2 = 0 ;
91901   Dali::ImageDimensions arg3 ;
91902   Dali::FittingMode::Type arg4 ;
91903   Dali::SamplingMode::Type arg5 ;
91904   bool arg6 ;
91905   Dali::ImageDimensions *argp3 ;
91906   uint32_t result;
91907
91908   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91909   if (!jarg2) {
91910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91911     return 0;
91912   }
91913   std::string arg2_str(jarg2);
91914   arg2 = &arg2_str;
91915   argp3 = (Dali::ImageDimensions *)jarg3;
91916   if (!argp3) {
91917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91918     return 0;
91919   }
91920   arg3 = *argp3;
91921   arg4 = (Dali::FittingMode::Type)jarg4;
91922   arg5 = (Dali::SamplingMode::Type)jarg5;
91923   arg6 = jarg6 ? true : false;
91924   {
91925     try {
91926       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91927     } catch (std::out_of_range& e) {
91928       {
91929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91930       };
91931     } catch (std::exception& e) {
91932       {
91933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91934       };
91935     } catch (Dali::DaliException e) {
91936       {
91937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91938       };
91939     } catch (...) {
91940       {
91941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91942       };
91943     }
91944   }
91945
91946   jresult = result;
91947
91948   //argout typemap for const std::string&
91949
91950   return jresult;
91951 }
91952
91953
91954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91955   unsigned int jresult ;
91956   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91957   uint32_t arg2 ;
91958   bool result;
91959
91960   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91961   arg2 = (uint32_t)jarg2;
91962   {
91963     try {
91964       result = (bool)(arg1)->Cancel(arg2);
91965     } catch (std::out_of_range& e) {
91966       {
91967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91968       };
91969     } catch (std::exception& e) {
91970       {
91971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91972       };
91973     } catch (Dali::DaliException e) {
91974       {
91975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91976       };
91977     } catch (...) {
91978       {
91979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91980       };
91981     }
91982   }
91983
91984   jresult = result;
91985   return jresult;
91986 }
91987
91988
91989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91990   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91991
91992   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91993   {
91994     try {
91995       (arg1)->CancelAll();
91996     } catch (std::out_of_range& e) {
91997       {
91998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91999       };
92000     } catch (std::exception& e) {
92001       {
92002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92003       };
92004     } catch (Dali::DaliException e) {
92005       {
92006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92007       };
92008     } catch (...) {
92009       {
92010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92011       };
92012     }
92013   }
92014
92015 }
92016
92017
92018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92019   void * jresult ;
92020   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92021   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92022
92023   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92024   {
92025     try {
92026       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92027     } catch (std::out_of_range& e) {
92028       {
92029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92030       };
92031     } catch (std::exception& e) {
92032       {
92033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92034       };
92035     } catch (Dali::DaliException e) {
92036       {
92037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92038       };
92039     } catch (...) {
92040       {
92041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92042       };
92043     }
92044   }
92045
92046   jresult = (void *)result;
92047   return jresult;
92048 }
92049
92050
92051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92052   void * jresult ;
92053   std::string *arg1 = 0 ;
92054   Dali::PixelData result;
92055
92056   if (!jarg1) {
92057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92058     return 0;
92059   }
92060   std::string arg1_str(jarg1);
92061   arg1 = &arg1_str;
92062   {
92063     try {
92064       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92065     } catch (std::out_of_range& e) {
92066       {
92067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92068       };
92069     } catch (std::exception& e) {
92070       {
92071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92072       };
92073     } catch (Dali::DaliException e) {
92074       {
92075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92076       };
92077     } catch (...) {
92078       {
92079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92080       };
92081     }
92082   }
92083
92084   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92085
92086   //argout typemap for const std::string&
92087
92088   return jresult;
92089 }
92090
92091
92092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92093   void * jresult ;
92094   std::string *arg1 = 0 ;
92095   Dali::ImageDimensions arg2 ;
92096   Dali::ImageDimensions *argp2 ;
92097   Dali::PixelData result;
92098
92099   if (!jarg1) {
92100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92101     return 0;
92102   }
92103   std::string arg1_str(jarg1);
92104   arg1 = &arg1_str;
92105   argp2 = (Dali::ImageDimensions *)jarg2;
92106   if (!argp2) {
92107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92108     return 0;
92109   }
92110   arg2 = *argp2;
92111   {
92112     try {
92113       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92114     } catch (std::out_of_range& e) {
92115       {
92116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92117       };
92118     } catch (std::exception& e) {
92119       {
92120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92121       };
92122     } catch (Dali::DaliException e) {
92123       {
92124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92125       };
92126     } catch (...) {
92127       {
92128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92129       };
92130     }
92131   }
92132
92133   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92134
92135   //argout typemap for const std::string&
92136
92137   return jresult;
92138 }
92139
92140
92141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92142   void * jresult ;
92143   std::string *arg1 = 0 ;
92144   Dali::ImageDimensions arg2 ;
92145   Dali::FittingMode::Type arg3 ;
92146   Dali::SamplingMode::Type arg4 ;
92147   bool arg5 ;
92148   Dali::ImageDimensions *argp2 ;
92149   Dali::PixelData result;
92150
92151   if (!jarg1) {
92152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92153     return 0;
92154   }
92155   std::string arg1_str(jarg1);
92156   arg1 = &arg1_str;
92157   argp2 = (Dali::ImageDimensions *)jarg2;
92158   if (!argp2) {
92159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92160     return 0;
92161   }
92162   arg2 = *argp2;
92163   arg3 = (Dali::FittingMode::Type)jarg3;
92164   arg4 = (Dali::SamplingMode::Type)jarg4;
92165   arg5 = jarg5 ? true : false;
92166   {
92167     try {
92168       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92169     } catch (std::out_of_range& e) {
92170       {
92171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92172       };
92173     } catch (std::exception& e) {
92174       {
92175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92176       };
92177     } catch (Dali::DaliException e) {
92178       {
92179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92180       };
92181     } catch (...) {
92182       {
92183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92184       };
92185     }
92186   }
92187
92188   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92189
92190   //argout typemap for const std::string&
92191
92192   return jresult;
92193 }
92194
92195
92196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92197   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92198
92199   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92200   {
92201     try {
92202       delete arg1;
92203     } catch (std::out_of_range& e) {
92204       {
92205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92206       };
92207     } catch (std::exception& e) {
92208       {
92209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92210       };
92211     } catch (Dali::DaliException e) {
92212       {
92213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92214       };
92215     } catch (...) {
92216       {
92217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92218       };
92219     }
92220   }
92221
92222 }
92223
92224
92225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92226   void * jresult ;
92227   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92228   Dali::Actor arg2 ;
92229   Dali::Actor arg3 ;
92230   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92231   Dali::Actor *argp2 ;
92232   Dali::Actor *argp3 ;
92233   Dali::Actor result;
92234
92235   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92236   argp2 = (Dali::Actor *)jarg2;
92237   if (!argp2) {
92238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92239     return 0;
92240   }
92241   arg2 = *argp2;
92242   argp3 = (Dali::Actor *)jarg3;
92243   if (!argp3) {
92244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92245     return 0;
92246   }
92247   arg3 = *argp3;
92248   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92249   {
92250     try {
92251       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92252     } catch (std::out_of_range& e) {
92253       {
92254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92255       };
92256     } catch (std::exception& e) {
92257       {
92258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92259       };
92260     } catch (Dali::DaliException e) {
92261       {
92262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92263       };
92264     } catch (...) {
92265       {
92266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92267       };
92268     }
92269   }
92270
92271   jresult = new Dali::Actor((const Dali::Actor &)result);
92272   return jresult;
92273 }
92274
92275
92276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92277   void * jresult ;
92278   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92279
92280   {
92281     try {
92282       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92283     } catch (std::out_of_range& e) {
92284       {
92285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92286       };
92287     } catch (std::exception& e) {
92288       {
92289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92290       };
92291     } catch (Dali::DaliException e) {
92292       {
92293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92294       };
92295     } catch (...) {
92296       {
92297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92298       };
92299     }
92300   }
92301
92302   jresult = (void *)result;
92303   return jresult;
92304 }
92305
92306
92307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92308   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92309   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92310   if (director) {
92311     director->swig_connect_director(callback0);
92312   }
92313 }
92314
92315
92316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92317   KeyboardFocusManager arg1 ;
92318   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92319   KeyboardFocusManager *argp1 ;
92320
92321   argp1 = (KeyboardFocusManager *)jarg1;
92322   if (!argp1) {
92323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92324     return ;
92325   }
92326   arg1 = *argp1;
92327   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92328   if (!arg2) {
92329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92330     return ;
92331   }
92332   {
92333     try {
92334       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92335     } catch (std::out_of_range& e) {
92336       {
92337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92338       };
92339     } catch (std::exception& e) {
92340       {
92341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92342       };
92343     } catch (Dali::DaliException e) {
92344       {
92345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92346       };
92347     } catch (...) {
92348       {
92349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92350       };
92351     }
92352   }
92353
92354 }
92355
92356
92357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92358   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92359
92360   arg1 = (std::vector< unsigned int > *)jarg1;
92361   {
92362     try {
92363       (arg1)->clear();
92364     } catch (std::out_of_range& e) {
92365       {
92366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92367       };
92368     } catch (std::exception& e) {
92369       {
92370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92371       };
92372     } catch (Dali::DaliException e) {
92373       {
92374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92375       };
92376     } catch (...) {
92377       {
92378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92379       };
92380     }
92381   }
92382
92383 }
92384
92385
92386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92387   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92388   unsigned int *arg2 = 0 ;
92389   unsigned int temp2 ;
92390
92391   arg1 = (std::vector< unsigned int > *)jarg1;
92392   temp2 = (unsigned int)jarg2;
92393   arg2 = &temp2;
92394   {
92395     try {
92396       (arg1)->push_back((unsigned int const &)*arg2);
92397     } catch (std::out_of_range& e) {
92398       {
92399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92400       };
92401     } catch (std::exception& e) {
92402       {
92403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92404       };
92405     } catch (Dali::DaliException e) {
92406       {
92407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92408       };
92409     } catch (...) {
92410       {
92411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92412       };
92413     }
92414   }
92415
92416 }
92417
92418
92419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92420   unsigned long jresult ;
92421   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92422   std::vector< unsigned int >::size_type result;
92423
92424   arg1 = (std::vector< unsigned int > *)jarg1;
92425   {
92426     try {
92427       result = ((std::vector< unsigned int > const *)arg1)->size();
92428     } catch (std::out_of_range& e) {
92429       {
92430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92431       };
92432     } catch (std::exception& e) {
92433       {
92434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92435       };
92436     } catch (Dali::DaliException e) {
92437       {
92438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92439       };
92440     } catch (...) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92443       };
92444     }
92445   }
92446
92447   jresult = (unsigned long)result;
92448   return jresult;
92449 }
92450
92451
92452 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92453   unsigned long jresult ;
92454   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92455   std::vector< unsigned int >::size_type result;
92456
92457   arg1 = (std::vector< unsigned int > *)jarg1;
92458   {
92459     try {
92460       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92461     } catch (std::out_of_range& e) {
92462       {
92463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92464       };
92465     } catch (std::exception& e) {
92466       {
92467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92468       };
92469     } catch (Dali::DaliException e) {
92470       {
92471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92472       };
92473     } catch (...) {
92474       {
92475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92476       };
92477     }
92478   }
92479
92480   jresult = (unsigned long)result;
92481   return jresult;
92482 }
92483
92484
92485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92486   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92487   std::vector< unsigned int >::size_type arg2 ;
92488
92489   arg1 = (std::vector< unsigned int > *)jarg1;
92490   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92491   {
92492     try {
92493       (arg1)->reserve(arg2);
92494     } catch (std::out_of_range& e) {
92495       {
92496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92497       };
92498     } catch (std::exception& e) {
92499       {
92500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92501       };
92502     } catch (Dali::DaliException e) {
92503       {
92504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92505       };
92506     } catch (...) {
92507       {
92508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92509       };
92510     }
92511   }
92512
92513 }
92514
92515
92516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92517   void * jresult ;
92518   std::vector< unsigned int > *result = 0 ;
92519
92520   {
92521     try {
92522       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92523     } catch (std::out_of_range& e) {
92524       {
92525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92526       };
92527     } catch (std::exception& e) {
92528       {
92529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92530       };
92531     } catch (Dali::DaliException e) {
92532       {
92533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92534       };
92535     } catch (...) {
92536       {
92537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92538       };
92539     }
92540   }
92541
92542   jresult = (void *)result;
92543   return jresult;
92544 }
92545
92546
92547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92548   void * jresult ;
92549   std::vector< unsigned int > *arg1 = 0 ;
92550   std::vector< unsigned int > *result = 0 ;
92551
92552   arg1 = (std::vector< unsigned int > *)jarg1;
92553   if (!arg1) {
92554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92555     return 0;
92556   }
92557   {
92558     try {
92559       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92560     } catch (std::out_of_range& e) {
92561       {
92562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92563       };
92564     } catch (std::exception& e) {
92565       {
92566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92567       };
92568     } catch (Dali::DaliException e) {
92569       {
92570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92571       };
92572     } catch (...) {
92573       {
92574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92575       };
92576     }
92577   }
92578
92579   jresult = (void *)result;
92580   return jresult;
92581 }
92582
92583
92584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92585   void * jresult ;
92586   int arg1 ;
92587   std::vector< unsigned int > *result = 0 ;
92588
92589   arg1 = (int)jarg1;
92590   {
92591     try {
92592       try {
92593         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92594       }
92595       catch(std::out_of_range &_e) {
92596         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92597         return 0;
92598       }
92599
92600     } catch (std::out_of_range& e) {
92601       {
92602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92603       };
92604     } catch (std::exception& e) {
92605       {
92606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (Dali::DaliException e) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92611       };
92612     } catch (...) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92615       };
92616     }
92617   }
92618
92619   jresult = (void *)result;
92620   return jresult;
92621 }
92622
92623
92624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92625   unsigned int jresult ;
92626   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92627   int arg2 ;
92628   unsigned int result;
92629
92630   arg1 = (std::vector< unsigned int > *)jarg1;
92631   arg2 = (int)jarg2;
92632   {
92633     try {
92634       try {
92635         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92636       }
92637       catch(std::out_of_range &_e) {
92638         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92639         return 0;
92640       }
92641
92642     } catch (std::out_of_range& e) {
92643       {
92644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92645       };
92646     } catch (std::exception& e) {
92647       {
92648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92649       };
92650     } catch (Dali::DaliException e) {
92651       {
92652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92653       };
92654     } catch (...) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92657       };
92658     }
92659   }
92660
92661   jresult = result;
92662   return jresult;
92663 }
92664
92665
92666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92667   unsigned int jresult ;
92668   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92669   int arg2 ;
92670   unsigned int *result = 0 ;
92671
92672   arg1 = (std::vector< unsigned int > *)jarg1;
92673   arg2 = (int)jarg2;
92674   {
92675     try {
92676       try {
92677         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92678       }
92679       catch(std::out_of_range &_e) {
92680         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92681         return 0;
92682       }
92683
92684     } catch (std::out_of_range& e) {
92685       {
92686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92687       };
92688     } catch (std::exception& e) {
92689       {
92690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92691       };
92692     } catch (Dali::DaliException e) {
92693       {
92694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92695       };
92696     } catch (...) {
92697       {
92698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92699       };
92700     }
92701   }
92702
92703   jresult = *result;
92704   return jresult;
92705 }
92706
92707
92708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92709   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92710   int arg2 ;
92711   unsigned int *arg3 = 0 ;
92712   unsigned int temp3 ;
92713
92714   arg1 = (std::vector< unsigned int > *)jarg1;
92715   arg2 = (int)jarg2;
92716   temp3 = (unsigned int)jarg3;
92717   arg3 = &temp3;
92718   {
92719     try {
92720       try {
92721         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92722       }
92723       catch(std::out_of_range &_e) {
92724         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92725         return ;
92726       }
92727
92728     } catch (std::out_of_range& e) {
92729       {
92730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92731       };
92732     } catch (std::exception& e) {
92733       {
92734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92735       };
92736     } catch (Dali::DaliException e) {
92737       {
92738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92739       };
92740     } catch (...) {
92741       {
92742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92743       };
92744     }
92745   }
92746
92747 }
92748
92749
92750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92751   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92752   std::vector< unsigned int > *arg2 = 0 ;
92753
92754   arg1 = (std::vector< unsigned int > *)jarg1;
92755   arg2 = (std::vector< unsigned int > *)jarg2;
92756   if (!arg2) {
92757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92758     return ;
92759   }
92760   {
92761     try {
92762       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92763     } catch (std::out_of_range& e) {
92764       {
92765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92766       };
92767     } catch (std::exception& e) {
92768       {
92769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92770       };
92771     } catch (Dali::DaliException e) {
92772       {
92773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92774       };
92775     } catch (...) {
92776       {
92777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92778       };
92779     }
92780   }
92781
92782 }
92783
92784
92785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92786   void * jresult ;
92787   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92788   int arg2 ;
92789   int arg3 ;
92790   std::vector< unsigned int > *result = 0 ;
92791
92792   arg1 = (std::vector< unsigned int > *)jarg1;
92793   arg2 = (int)jarg2;
92794   arg3 = (int)jarg3;
92795   {
92796     try {
92797       try {
92798         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92799       }
92800       catch(std::out_of_range &_e) {
92801         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92802         return 0;
92803       }
92804       catch(std::invalid_argument &_e) {
92805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92806         return 0;
92807       }
92808
92809     } catch (std::out_of_range& e) {
92810       {
92811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92812       };
92813     } catch (std::exception& e) {
92814       {
92815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92816       };
92817     } catch (Dali::DaliException e) {
92818       {
92819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92820       };
92821     } catch (...) {
92822       {
92823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92824       };
92825     }
92826   }
92827
92828   jresult = (void *)result;
92829   return jresult;
92830 }
92831
92832
92833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92834   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92835   int arg2 ;
92836   unsigned int *arg3 = 0 ;
92837   unsigned int temp3 ;
92838
92839   arg1 = (std::vector< unsigned int > *)jarg1;
92840   arg2 = (int)jarg2;
92841   temp3 = (unsigned int)jarg3;
92842   arg3 = &temp3;
92843   {
92844     try {
92845       try {
92846         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92847       }
92848       catch(std::out_of_range &_e) {
92849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92850         return ;
92851       }
92852
92853     } catch (std::out_of_range& e) {
92854       {
92855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92856       };
92857     } catch (std::exception& e) {
92858       {
92859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92860       };
92861     } catch (Dali::DaliException e) {
92862       {
92863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92864       };
92865     } catch (...) {
92866       {
92867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92868       };
92869     }
92870   }
92871
92872 }
92873
92874
92875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92876   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92877   int arg2 ;
92878   std::vector< unsigned int > *arg3 = 0 ;
92879
92880   arg1 = (std::vector< unsigned int > *)jarg1;
92881   arg2 = (int)jarg2;
92882   arg3 = (std::vector< unsigned int > *)jarg3;
92883   if (!arg3) {
92884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92885     return ;
92886   }
92887   {
92888     try {
92889       try {
92890         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92891       }
92892       catch(std::out_of_range &_e) {
92893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92894         return ;
92895       }
92896
92897     } catch (std::out_of_range& e) {
92898       {
92899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92900       };
92901     } catch (std::exception& e) {
92902       {
92903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92904       };
92905     } catch (Dali::DaliException e) {
92906       {
92907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92908       };
92909     } catch (...) {
92910       {
92911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92912       };
92913     }
92914   }
92915
92916 }
92917
92918
92919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92920   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92921   int arg2 ;
92922
92923   arg1 = (std::vector< unsigned int > *)jarg1;
92924   arg2 = (int)jarg2;
92925   {
92926     try {
92927       try {
92928         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92929       }
92930       catch(std::out_of_range &_e) {
92931         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92932         return ;
92933       }
92934
92935     } catch (std::out_of_range& e) {
92936       {
92937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92938       };
92939     } catch (std::exception& e) {
92940       {
92941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92942       };
92943     } catch (Dali::DaliException e) {
92944       {
92945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92946       };
92947     } catch (...) {
92948       {
92949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92950       };
92951     }
92952   }
92953
92954 }
92955
92956
92957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92958   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92959   int arg2 ;
92960   int arg3 ;
92961
92962   arg1 = (std::vector< unsigned int > *)jarg1;
92963   arg2 = (int)jarg2;
92964   arg3 = (int)jarg3;
92965   {
92966     try {
92967       try {
92968         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92969       }
92970       catch(std::out_of_range &_e) {
92971         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92972         return ;
92973       }
92974       catch(std::invalid_argument &_e) {
92975         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92976         return ;
92977       }
92978
92979     } catch (std::out_of_range& e) {
92980       {
92981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92982       };
92983     } catch (std::exception& e) {
92984       {
92985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92986       };
92987     } catch (Dali::DaliException e) {
92988       {
92989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92990       };
92991     } catch (...) {
92992       {
92993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92994       };
92995     }
92996   }
92997
92998 }
92999
93000
93001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93002   void * jresult ;
93003   unsigned int *arg1 = 0 ;
93004   int arg2 ;
93005   unsigned int temp1 ;
93006   std::vector< unsigned int > *result = 0 ;
93007
93008   temp1 = (unsigned int)jarg1;
93009   arg1 = &temp1;
93010   arg2 = (int)jarg2;
93011   {
93012     try {
93013       try {
93014         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93015       }
93016       catch(std::out_of_range &_e) {
93017         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93018         return 0;
93019       }
93020
93021     } catch (std::out_of_range& e) {
93022       {
93023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93024       };
93025     } catch (std::exception& e) {
93026       {
93027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93028       };
93029     } catch (Dali::DaliException e) {
93030       {
93031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93032       };
93033     } catch (...) {
93034       {
93035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93036       };
93037     }
93038   }
93039
93040   jresult = (void *)result;
93041   return jresult;
93042 }
93043
93044
93045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93046   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93047
93048   arg1 = (std::vector< unsigned int > *)jarg1;
93049   {
93050     try {
93051       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93052     } catch (std::out_of_range& e) {
93053       {
93054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93055       };
93056     } catch (std::exception& e) {
93057       {
93058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93059       };
93060     } catch (Dali::DaliException e) {
93061       {
93062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93063       };
93064     } catch (...) {
93065       {
93066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93067       };
93068     }
93069   }
93070
93071 }
93072
93073
93074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93075   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93076   int arg2 ;
93077   int arg3 ;
93078
93079   arg1 = (std::vector< unsigned int > *)jarg1;
93080   arg2 = (int)jarg2;
93081   arg3 = (int)jarg3;
93082   {
93083     try {
93084       try {
93085         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93086       }
93087       catch(std::out_of_range &_e) {
93088         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93089         return ;
93090       }
93091       catch(std::invalid_argument &_e) {
93092         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93093         return ;
93094       }
93095
93096     } catch (std::out_of_range& e) {
93097       {
93098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93099       };
93100     } catch (std::exception& e) {
93101       {
93102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93103       };
93104     } catch (Dali::DaliException e) {
93105       {
93106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93107       };
93108     } catch (...) {
93109       {
93110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93111       };
93112     }
93113   }
93114
93115 }
93116
93117
93118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93119   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93120   int arg2 ;
93121   std::vector< unsigned int > *arg3 = 0 ;
93122
93123   arg1 = (std::vector< unsigned int > *)jarg1;
93124   arg2 = (int)jarg2;
93125   arg3 = (std::vector< unsigned int > *)jarg3;
93126   if (!arg3) {
93127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93128     return ;
93129   }
93130   {
93131     try {
93132       try {
93133         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93134       }
93135       catch(std::out_of_range &_e) {
93136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93137         return ;
93138       }
93139
93140     } catch (std::out_of_range& e) {
93141       {
93142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93143       };
93144     } catch (std::exception& e) {
93145       {
93146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93147       };
93148     } catch (Dali::DaliException e) {
93149       {
93150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93151       };
93152     } catch (...) {
93153       {
93154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93155       };
93156     }
93157   }
93158
93159 }
93160
93161
93162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93163   unsigned int jresult ;
93164   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93165   unsigned int *arg2 = 0 ;
93166   unsigned int temp2 ;
93167   bool result;
93168
93169   arg1 = (std::vector< unsigned int > *)jarg1;
93170   temp2 = (unsigned int)jarg2;
93171   arg2 = &temp2;
93172   {
93173     try {
93174       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93175     } catch (std::out_of_range& e) {
93176       {
93177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93178       };
93179     } catch (std::exception& e) {
93180       {
93181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93182       };
93183     } catch (Dali::DaliException e) {
93184       {
93185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93186       };
93187     } catch (...) {
93188       {
93189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93190       };
93191     }
93192   }
93193
93194   jresult = result;
93195   return jresult;
93196 }
93197
93198
93199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93200   int jresult ;
93201   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93202   unsigned int *arg2 = 0 ;
93203   unsigned int temp2 ;
93204   int result;
93205
93206   arg1 = (std::vector< unsigned int > *)jarg1;
93207   temp2 = (unsigned int)jarg2;
93208   arg2 = &temp2;
93209   {
93210     try {
93211       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93212     } catch (std::out_of_range& e) {
93213       {
93214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93215       };
93216     } catch (std::exception& e) {
93217       {
93218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93219       };
93220     } catch (Dali::DaliException e) {
93221       {
93222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93223       };
93224     } catch (...) {
93225       {
93226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93227       };
93228     }
93229   }
93230
93231   jresult = result;
93232   return jresult;
93233 }
93234
93235
93236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93237   int jresult ;
93238   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93239   unsigned int *arg2 = 0 ;
93240   unsigned int temp2 ;
93241   int result;
93242
93243   arg1 = (std::vector< unsigned int > *)jarg1;
93244   temp2 = (unsigned int)jarg2;
93245   arg2 = &temp2;
93246   {
93247     try {
93248       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93249     } catch (std::out_of_range& e) {
93250       {
93251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93252       };
93253     } catch (std::exception& e) {
93254       {
93255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93256       };
93257     } catch (Dali::DaliException e) {
93258       {
93259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93260       };
93261     } catch (...) {
93262       {
93263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93264       };
93265     }
93266   }
93267
93268   jresult = result;
93269   return jresult;
93270 }
93271
93272
93273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93274   unsigned int jresult ;
93275   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93276   unsigned int *arg2 = 0 ;
93277   unsigned int temp2 ;
93278   bool result;
93279
93280   arg1 = (std::vector< unsigned int > *)jarg1;
93281   temp2 = (unsigned int)jarg2;
93282   arg2 = &temp2;
93283   {
93284     try {
93285       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93286     } catch (std::out_of_range& e) {
93287       {
93288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93289       };
93290     } catch (std::exception& e) {
93291       {
93292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93293       };
93294     } catch (Dali::DaliException e) {
93295       {
93296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93297       };
93298     } catch (...) {
93299       {
93300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93301       };
93302     }
93303   }
93304
93305   jresult = result;
93306   return jresult;
93307 }
93308
93309
93310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93311   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93312
93313   arg1 = (std::vector< unsigned int > *)jarg1;
93314   {
93315     try {
93316       delete arg1;
93317     } catch (std::out_of_range& e) {
93318       {
93319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93320       };
93321     } catch (std::exception& e) {
93322       {
93323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93324       };
93325     } catch (Dali::DaliException e) {
93326       {
93327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93328       };
93329     } catch (...) {
93330       {
93331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93332       };
93333     }
93334   }
93335
93336 }
93337
93338
93339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93340   void * jresult ;
93341   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93342
93343   {
93344     try {
93345       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93346     } catch (std::out_of_range& e) {
93347       {
93348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93349       };
93350     } catch (std::exception& e) {
93351       {
93352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93353       };
93354     } catch (Dali::DaliException e) {
93355       {
93356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93357       };
93358     } catch (...) {
93359       {
93360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93361       };
93362     }
93363   }
93364
93365   jresult = (void *)result;
93366   return jresult;
93367 }
93368
93369
93370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93371   void * jresult ;
93372   unsigned int arg1 ;
93373   Dali::Actor arg2 ;
93374   Dali::Actor *argp2 ;
93375   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93376
93377   arg1 = (unsigned int)jarg1;
93378   argp2 = (Dali::Actor *)jarg2;
93379   if (!argp2) {
93380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93381     return 0;
93382   }
93383   arg2 = *argp2;
93384   {
93385     try {
93386       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93387     } catch (std::out_of_range& e) {
93388       {
93389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93390       };
93391     } catch (std::exception& e) {
93392       {
93393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93394       };
93395     } catch (Dali::DaliException e) {
93396       {
93397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93398       };
93399     } catch (...) {
93400       {
93401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93402       };
93403     }
93404   }
93405
93406   jresult = (void *)result;
93407   return jresult;
93408 }
93409
93410
93411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93412   void * jresult ;
93413   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93414   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93415
93416   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93417   if (!arg1) {
93418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93419     return 0;
93420   }
93421   {
93422     try {
93423       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93424     } catch (std::out_of_range& e) {
93425       {
93426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93427       };
93428     } catch (std::exception& e) {
93429       {
93430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93431       };
93432     } catch (Dali::DaliException e) {
93433       {
93434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93435       };
93436     } catch (...) {
93437       {
93438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93439       };
93440     }
93441   }
93442
93443   jresult = (void *)result;
93444   return jresult;
93445 }
93446
93447
93448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93449   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93450   unsigned int arg2 ;
93451
93452   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93453   arg2 = (unsigned int)jarg2;
93454   if (arg1) (arg1)->first = arg2;
93455 }
93456
93457
93458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93459   unsigned int jresult ;
93460   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93461   unsigned int result;
93462
93463   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93464   result = (unsigned int) ((arg1)->first);
93465   jresult = result;
93466   return jresult;
93467 }
93468
93469
93470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93471   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93472   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93473
93474   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93475   arg2 = (Dali::Actor *)jarg2;
93476   if (arg1) (arg1)->second = *arg2;
93477 }
93478
93479
93480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93481   void * jresult ;
93482   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93483   Dali::Actor *result = 0 ;
93484
93485   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93486   result = (Dali::Actor *)& ((arg1)->second);
93487   jresult = (void *)result;
93488   return jresult;
93489 }
93490
93491
93492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93493   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93494
93495   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93496   {
93497     try {
93498       delete arg1;
93499     } catch (std::out_of_range& e) {
93500       {
93501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93502       };
93503     } catch (std::exception& e) {
93504       {
93505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93506       };
93507     } catch (Dali::DaliException e) {
93508       {
93509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93510       };
93511     } catch (...) {
93512       {
93513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93514       };
93515     }
93516   }
93517
93518 }
93519
93520
93521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93522   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93523
93524   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93525   {
93526     try {
93527       (arg1)->clear();
93528     } catch (std::out_of_range& e) {
93529       {
93530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93531       };
93532     } catch (std::exception& e) {
93533       {
93534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93535       };
93536     } catch (Dali::DaliException e) {
93537       {
93538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93539       };
93540     } catch (...) {
93541       {
93542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93543       };
93544     }
93545   }
93546
93547 }
93548
93549
93550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93551   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93552   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93553
93554   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93555   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93556   if (!arg2) {
93557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93558     return ;
93559   }
93560   {
93561     try {
93562       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93563     } catch (std::out_of_range& e) {
93564       {
93565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93566       };
93567     } catch (std::exception& e) {
93568       {
93569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93570       };
93571     } catch (Dali::DaliException e) {
93572       {
93573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93574       };
93575     } catch (...) {
93576       {
93577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93578       };
93579     }
93580   }
93581
93582 }
93583
93584
93585 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93586   unsigned long jresult ;
93587   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93588   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93589
93590   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93591   {
93592     try {
93593       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93594     } catch (std::out_of_range& e) {
93595       {
93596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93597       };
93598     } catch (std::exception& e) {
93599       {
93600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93601       };
93602     } catch (Dali::DaliException e) {
93603       {
93604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93605       };
93606     } catch (...) {
93607       {
93608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93609       };
93610     }
93611   }
93612
93613   jresult = (unsigned long)result;
93614   return jresult;
93615 }
93616
93617
93618 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93619   unsigned long jresult ;
93620   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93621   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93622
93623   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93624   {
93625     try {
93626       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93627     } catch (std::out_of_range& e) {
93628       {
93629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93630       };
93631     } catch (std::exception& e) {
93632       {
93633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93634       };
93635     } catch (Dali::DaliException e) {
93636       {
93637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93638       };
93639     } catch (...) {
93640       {
93641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93642       };
93643     }
93644   }
93645
93646   jresult = (unsigned long)result;
93647   return jresult;
93648 }
93649
93650
93651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93652   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93653   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93654
93655   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93656   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93657   {
93658     try {
93659       (arg1)->reserve(arg2);
93660     } catch (std::out_of_range& e) {
93661       {
93662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93663       };
93664     } catch (std::exception& e) {
93665       {
93666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93667       };
93668     } catch (Dali::DaliException e) {
93669       {
93670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93671       };
93672     } catch (...) {
93673       {
93674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93675       };
93676     }
93677   }
93678
93679 }
93680
93681
93682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93683   void * jresult ;
93684   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93685
93686   {
93687     try {
93688       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93689     } catch (std::out_of_range& e) {
93690       {
93691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93692       };
93693     } catch (std::exception& e) {
93694       {
93695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93696       };
93697     } catch (Dali::DaliException e) {
93698       {
93699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93700       };
93701     } catch (...) {
93702       {
93703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93704       };
93705     }
93706   }
93707
93708   jresult = (void *)result;
93709   return jresult;
93710 }
93711
93712
93713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93714   void * jresult ;
93715   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93716   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93717
93718   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93719   if (!arg1) {
93720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93721     return 0;
93722   }
93723   {
93724     try {
93725       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);
93726     } catch (std::out_of_range& e) {
93727       {
93728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93729       };
93730     } catch (std::exception& e) {
93731       {
93732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93733       };
93734     } catch (Dali::DaliException e) {
93735       {
93736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93737       };
93738     } catch (...) {
93739       {
93740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93741       };
93742     }
93743   }
93744
93745   jresult = (void *)result;
93746   return jresult;
93747 }
93748
93749
93750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93751   void * jresult ;
93752   int arg1 ;
93753   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93754
93755   arg1 = (int)jarg1;
93756   {
93757     try {
93758       try {
93759         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);
93760       }
93761       catch(std::out_of_range &_e) {
93762         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93763         return 0;
93764       }
93765
93766     } catch (std::out_of_range& e) {
93767       {
93768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93769       };
93770     } catch (std::exception& e) {
93771       {
93772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93773       };
93774     } catch (Dali::DaliException e) {
93775       {
93776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93777       };
93778     } catch (...) {
93779       {
93780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93781       };
93782     }
93783   }
93784
93785   jresult = (void *)result;
93786   return jresult;
93787 }
93788
93789
93790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93791   void * jresult ;
93792   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93793   int arg2 ;
93794   std::pair< unsigned int,Dali::Actor > result;
93795
93796   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93797   arg2 = (int)jarg2;
93798   {
93799     try {
93800       try {
93801         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93802       }
93803       catch(std::out_of_range &_e) {
93804         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93805         return 0;
93806       }
93807
93808     } catch (std::out_of_range& e) {
93809       {
93810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93811       };
93812     } catch (std::exception& e) {
93813       {
93814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93815       };
93816     } catch (Dali::DaliException e) {
93817       {
93818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93819       };
93820     } catch (...) {
93821       {
93822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93823       };
93824     }
93825   }
93826
93827   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93828   return jresult;
93829 }
93830
93831
93832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93833   void * jresult ;
93834   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93835   int arg2 ;
93836   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93837
93838   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93839   arg2 = (int)jarg2;
93840   {
93841     try {
93842       try {
93843         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93844       }
93845       catch(std::out_of_range &_e) {
93846         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93847         return 0;
93848       }
93849
93850     } catch (std::out_of_range& e) {
93851       {
93852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93853       };
93854     } catch (std::exception& e) {
93855       {
93856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93857       };
93858     } catch (Dali::DaliException e) {
93859       {
93860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93861       };
93862     } catch (...) {
93863       {
93864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93865       };
93866     }
93867   }
93868
93869   jresult = (void *)result;
93870   return jresult;
93871 }
93872
93873
93874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93875   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93876   int arg2 ;
93877   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93878
93879   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93880   arg2 = (int)jarg2;
93881   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93882   if (!arg3) {
93883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93884     return ;
93885   }
93886   {
93887     try {
93888       try {
93889         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);
93890       }
93891       catch(std::out_of_range &_e) {
93892         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93893         return ;
93894       }
93895
93896     } catch (std::out_of_range& e) {
93897       {
93898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93899       };
93900     } catch (std::exception& e) {
93901       {
93902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93903       };
93904     } catch (Dali::DaliException e) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93907       };
93908     } catch (...) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93911       };
93912     }
93913   }
93914
93915 }
93916
93917
93918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93919   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93920   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93921
93922   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93923   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93924   if (!arg2) {
93925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93926     return ;
93927   }
93928   {
93929     try {
93930       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);
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_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93954   void * jresult ;
93955   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93956   int arg2 ;
93957   int arg3 ;
93958   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93959
93960   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93961   arg2 = (int)jarg2;
93962   arg3 = (int)jarg3;
93963   {
93964     try {
93965       try {
93966         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);
93967       }
93968       catch(std::out_of_range &_e) {
93969         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93970         return 0;
93971       }
93972       catch(std::invalid_argument &_e) {
93973         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93974         return 0;
93975       }
93976
93977     } catch (std::out_of_range& e) {
93978       {
93979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93980       };
93981     } catch (std::exception& e) {
93982       {
93983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93984       };
93985     } catch (Dali::DaliException e) {
93986       {
93987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93988       };
93989     } catch (...) {
93990       {
93991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93992       };
93993     }
93994   }
93995
93996   jresult = (void *)result;
93997   return jresult;
93998 }
93999
94000
94001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94002   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94003   int arg2 ;
94004   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94005
94006   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94007   arg2 = (int)jarg2;
94008   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94009   if (!arg3) {
94010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94011     return ;
94012   }
94013   {
94014     try {
94015       try {
94016         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);
94017       }
94018       catch(std::out_of_range &_e) {
94019         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94020         return ;
94021       }
94022
94023     } catch (std::out_of_range& e) {
94024       {
94025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94026       };
94027     } catch (std::exception& e) {
94028       {
94029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94030       };
94031     } catch (Dali::DaliException e) {
94032       {
94033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94034       };
94035     } catch (...) {
94036       {
94037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94038       };
94039     }
94040   }
94041
94042 }
94043
94044
94045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94046   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94047   int arg2 ;
94048   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94049
94050   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94051   arg2 = (int)jarg2;
94052   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94053   if (!arg3) {
94054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94055     return ;
94056   }
94057   {
94058     try {
94059       try {
94060         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);
94061       }
94062       catch(std::out_of_range &_e) {
94063         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94064         return ;
94065       }
94066
94067     } catch (std::out_of_range& e) {
94068       {
94069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94070       };
94071     } catch (std::exception& e) {
94072       {
94073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94074       };
94075     } catch (Dali::DaliException e) {
94076       {
94077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94078       };
94079     } catch (...) {
94080       {
94081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94082       };
94083     }
94084   }
94085
94086 }
94087
94088
94089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94090   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94091   int arg2 ;
94092
94093   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94094   arg2 = (int)jarg2;
94095   {
94096     try {
94097       try {
94098         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94099       }
94100       catch(std::out_of_range &_e) {
94101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94102         return ;
94103       }
94104
94105     } catch (std::out_of_range& e) {
94106       {
94107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94108       };
94109     } catch (std::exception& e) {
94110       {
94111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94112       };
94113     } catch (Dali::DaliException e) {
94114       {
94115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94116       };
94117     } catch (...) {
94118       {
94119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94120       };
94121     }
94122   }
94123
94124 }
94125
94126
94127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94128   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94129   int arg2 ;
94130   int arg3 ;
94131
94132   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94133   arg2 = (int)jarg2;
94134   arg3 = (int)jarg3;
94135   {
94136     try {
94137       try {
94138         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94139       }
94140       catch(std::out_of_range &_e) {
94141         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94142         return ;
94143       }
94144       catch(std::invalid_argument &_e) {
94145         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94146         return ;
94147       }
94148
94149     } catch (std::out_of_range& e) {
94150       {
94151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94152       };
94153     } catch (std::exception& e) {
94154       {
94155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94156       };
94157     } catch (Dali::DaliException e) {
94158       {
94159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94160       };
94161     } catch (...) {
94162       {
94163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94164       };
94165     }
94166   }
94167
94168 }
94169
94170
94171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94172   void * jresult ;
94173   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94174   int arg2 ;
94175   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94176
94177   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94178   if (!arg1) {
94179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94180     return 0;
94181   }
94182   arg2 = (int)jarg2;
94183   {
94184     try {
94185       try {
94186         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);
94187       }
94188       catch(std::out_of_range &_e) {
94189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94190         return 0;
94191       }
94192
94193     } catch (std::out_of_range& e) {
94194       {
94195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94196       };
94197     } catch (std::exception& e) {
94198       {
94199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94200       };
94201     } catch (Dali::DaliException e) {
94202       {
94203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94204       };
94205     } catch (...) {
94206       {
94207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94208       };
94209     }
94210   }
94211
94212   jresult = (void *)result;
94213   return jresult;
94214 }
94215
94216
94217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94218   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94219
94220   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94221   {
94222     try {
94223       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94224     } catch (std::out_of_range& e) {
94225       {
94226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94227       };
94228     } catch (std::exception& e) {
94229       {
94230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94231       };
94232     } catch (Dali::DaliException e) {
94233       {
94234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94235       };
94236     } catch (...) {
94237       {
94238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94239       };
94240     }
94241   }
94242
94243 }
94244
94245
94246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94247   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94248   int arg2 ;
94249   int arg3 ;
94250
94251   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94252   arg2 = (int)jarg2;
94253   arg3 = (int)jarg3;
94254   {
94255     try {
94256       try {
94257         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94258       }
94259       catch(std::out_of_range &_e) {
94260         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94261         return ;
94262       }
94263       catch(std::invalid_argument &_e) {
94264         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94265         return ;
94266       }
94267
94268     } catch (std::out_of_range& e) {
94269       {
94270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94271       };
94272     } catch (std::exception& e) {
94273       {
94274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94275       };
94276     } catch (Dali::DaliException e) {
94277       {
94278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94279       };
94280     } catch (...) {
94281       {
94282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94283       };
94284     }
94285   }
94286
94287 }
94288
94289
94290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94291   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94292   int arg2 ;
94293   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94294
94295   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94296   arg2 = (int)jarg2;
94297   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94298   if (!arg3) {
94299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94300     return ;
94301   }
94302   {
94303     try {
94304       try {
94305         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);
94306       }
94307       catch(std::out_of_range &_e) {
94308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94309         return ;
94310       }
94311
94312     } catch (std::out_of_range& e) {
94313       {
94314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94315       };
94316     } catch (std::exception& e) {
94317       {
94318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94319       };
94320     } catch (Dali::DaliException e) {
94321       {
94322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94323       };
94324     } catch (...) {
94325       {
94326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94327       };
94328     }
94329   }
94330
94331 }
94332
94333
94334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94335   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94336
94337   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94338   {
94339     try {
94340       delete arg1;
94341     } catch (std::out_of_range& e) {
94342       {
94343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94344       };
94345     } catch (std::exception& e) {
94346       {
94347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94348       };
94349     } catch (Dali::DaliException e) {
94350       {
94351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94352       };
94353     } catch (...) {
94354       {
94355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94356       };
94357     }
94358   }
94359
94360 }
94361
94362
94363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94364   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94365
94366   arg1 = (std::vector< Dali::Actor > *)jarg1;
94367   {
94368     try {
94369       (arg1)->clear();
94370     } catch (std::out_of_range& e) {
94371       {
94372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94373       };
94374     } catch (std::exception& e) {
94375       {
94376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94377       };
94378     } catch (Dali::DaliException e) {
94379       {
94380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94381       };
94382     } catch (...) {
94383       {
94384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94385       };
94386     }
94387   }
94388
94389 }
94390
94391
94392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94393   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94394   Dali::Actor *arg2 = 0 ;
94395
94396   arg1 = (std::vector< Dali::Actor > *)jarg1;
94397   arg2 = (Dali::Actor *)jarg2;
94398   if (!arg2) {
94399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94400     return ;
94401   }
94402   {
94403     try {
94404       (arg1)->push_back((Dali::Actor const &)*arg2);
94405     } catch (std::out_of_range& e) {
94406       {
94407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94408       };
94409     } catch (std::exception& e) {
94410       {
94411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94412       };
94413     } catch (Dali::DaliException e) {
94414       {
94415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94416       };
94417     } catch (...) {
94418       {
94419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94420       };
94421     }
94422   }
94423
94424 }
94425
94426
94427 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94428   unsigned long jresult ;
94429   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94430   std::vector< Dali::Actor >::size_type result;
94431
94432   arg1 = (std::vector< Dali::Actor > *)jarg1;
94433   {
94434     try {
94435       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94436     } catch (std::out_of_range& e) {
94437       {
94438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94439       };
94440     } catch (std::exception& e) {
94441       {
94442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94443       };
94444     } catch (Dali::DaliException e) {
94445       {
94446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94447       };
94448     } catch (...) {
94449       {
94450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94451       };
94452     }
94453   }
94454
94455   jresult = (unsigned long)result;
94456   return jresult;
94457 }
94458
94459
94460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94461   unsigned long jresult ;
94462   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94463   std::vector< Dali::Actor >::size_type result;
94464
94465   arg1 = (std::vector< Dali::Actor > *)jarg1;
94466   {
94467     try {
94468       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94469     } catch (std::out_of_range& e) {
94470       {
94471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94472       };
94473     } catch (std::exception& e) {
94474       {
94475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94476       };
94477     } catch (Dali::DaliException e) {
94478       {
94479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94480       };
94481     } catch (...) {
94482       {
94483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94484       };
94485     }
94486   }
94487
94488   jresult = (unsigned long)result;
94489   return jresult;
94490 }
94491
94492
94493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94494   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94495   std::vector< Dali::Actor >::size_type arg2 ;
94496
94497   arg1 = (std::vector< Dali::Actor > *)jarg1;
94498   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94499   {
94500     try {
94501       (arg1)->reserve(arg2);
94502     } catch (std::out_of_range& e) {
94503       {
94504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94505       };
94506     } catch (std::exception& e) {
94507       {
94508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94509       };
94510     } catch (Dali::DaliException e) {
94511       {
94512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94513       };
94514     } catch (...) {
94515       {
94516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94517       };
94518     }
94519   }
94520
94521 }
94522
94523
94524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94525   void * jresult ;
94526   std::vector< Dali::Actor > *result = 0 ;
94527
94528   {
94529     try {
94530       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94531     } catch (std::out_of_range& e) {
94532       {
94533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94534       };
94535     } catch (std::exception& e) {
94536       {
94537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94538       };
94539     } catch (Dali::DaliException e) {
94540       {
94541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94542       };
94543     } catch (...) {
94544       {
94545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94546       };
94547     }
94548   }
94549
94550   jresult = (void *)result;
94551   return jresult;
94552 }
94553
94554
94555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94556   void * jresult ;
94557   std::vector< Dali::Actor > *arg1 = 0 ;
94558   std::vector< Dali::Actor > *result = 0 ;
94559
94560   arg1 = (std::vector< Dali::Actor > *)jarg1;
94561   if (!arg1) {
94562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94563     return 0;
94564   }
94565   {
94566     try {
94567       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94568     } catch (std::out_of_range& e) {
94569       {
94570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94571       };
94572     } catch (std::exception& e) {
94573       {
94574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94575       };
94576     } catch (Dali::DaliException e) {
94577       {
94578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94579       };
94580     } catch (...) {
94581       {
94582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94583       };
94584     }
94585   }
94586
94587   jresult = (void *)result;
94588   return jresult;
94589 }
94590
94591
94592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94593   void * jresult ;
94594   int arg1 ;
94595   std::vector< Dali::Actor > *result = 0 ;
94596
94597   arg1 = (int)jarg1;
94598   {
94599     try {
94600       try {
94601         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94602       }
94603       catch(std::out_of_range &_e) {
94604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94605         return 0;
94606       }
94607
94608     } catch (std::out_of_range& e) {
94609       {
94610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94611       };
94612     } catch (std::exception& e) {
94613       {
94614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94615       };
94616     } catch (Dali::DaliException e) {
94617       {
94618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94619       };
94620     } catch (...) {
94621       {
94622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94623       };
94624     }
94625   }
94626
94627   jresult = (void *)result;
94628   return jresult;
94629 }
94630
94631
94632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94633   void * jresult ;
94634   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94635   int arg2 ;
94636   Dali::Actor result;
94637
94638   arg1 = (std::vector< Dali::Actor > *)jarg1;
94639   arg2 = (int)jarg2;
94640   {
94641     try {
94642       try {
94643         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94644       }
94645       catch(std::out_of_range &_e) {
94646         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94647         return 0;
94648       }
94649
94650     } catch (std::out_of_range& e) {
94651       {
94652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94653       };
94654     } catch (std::exception& e) {
94655       {
94656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94657       };
94658     } catch (Dali::DaliException e) {
94659       {
94660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94661       };
94662     } catch (...) {
94663       {
94664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94665       };
94666     }
94667   }
94668
94669   jresult = new Dali::Actor((const Dali::Actor &)result);
94670   return jresult;
94671 }
94672
94673
94674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94675   void * jresult ;
94676   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94677   int arg2 ;
94678   Dali::Actor *result = 0 ;
94679
94680   arg1 = (std::vector< Dali::Actor > *)jarg1;
94681   arg2 = (int)jarg2;
94682   {
94683     try {
94684       try {
94685         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94686       }
94687       catch(std::out_of_range &_e) {
94688         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94689         return 0;
94690       }
94691
94692     } catch (std::out_of_range& e) {
94693       {
94694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94695       };
94696     } catch (std::exception& e) {
94697       {
94698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94699       };
94700     } catch (Dali::DaliException e) {
94701       {
94702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94703       };
94704     } catch (...) {
94705       {
94706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94707       };
94708     }
94709   }
94710
94711   jresult = (void *)result;
94712   return jresult;
94713 }
94714
94715
94716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94717   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94718   int arg2 ;
94719   Dali::Actor *arg3 = 0 ;
94720
94721   arg1 = (std::vector< Dali::Actor > *)jarg1;
94722   arg2 = (int)jarg2;
94723   arg3 = (Dali::Actor *)jarg3;
94724   if (!arg3) {
94725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94726     return ;
94727   }
94728   {
94729     try {
94730       try {
94731         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94732       }
94733       catch(std::out_of_range &_e) {
94734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94735         return ;
94736       }
94737
94738     } catch (std::out_of_range& e) {
94739       {
94740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94741       };
94742     } catch (std::exception& e) {
94743       {
94744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94745       };
94746     } catch (Dali::DaliException e) {
94747       {
94748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94749       };
94750     } catch (...) {
94751       {
94752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94753       };
94754     }
94755   }
94756
94757 }
94758
94759
94760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94761   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94762   std::vector< Dali::Actor > *arg2 = 0 ;
94763
94764   arg1 = (std::vector< Dali::Actor > *)jarg1;
94765   arg2 = (std::vector< Dali::Actor > *)jarg2;
94766   if (!arg2) {
94767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94768     return ;
94769   }
94770   {
94771     try {
94772       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94773     } catch (std::out_of_range& e) {
94774       {
94775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94776       };
94777     } catch (std::exception& e) {
94778       {
94779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94780       };
94781     } catch (Dali::DaliException e) {
94782       {
94783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94784       };
94785     } catch (...) {
94786       {
94787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94788       };
94789     }
94790   }
94791
94792 }
94793
94794
94795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94796   void * jresult ;
94797   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94798   int arg2 ;
94799   int arg3 ;
94800   std::vector< Dali::Actor > *result = 0 ;
94801
94802   arg1 = (std::vector< Dali::Actor > *)jarg1;
94803   arg2 = (int)jarg2;
94804   arg3 = (int)jarg3;
94805   {
94806     try {
94807       try {
94808         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94809       }
94810       catch(std::out_of_range &_e) {
94811         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94812         return 0;
94813       }
94814       catch(std::invalid_argument &_e) {
94815         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94816         return 0;
94817       }
94818
94819     } catch (std::out_of_range& e) {
94820       {
94821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94822       };
94823     } catch (std::exception& e) {
94824       {
94825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94826       };
94827     } catch (Dali::DaliException e) {
94828       {
94829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94830       };
94831     } catch (...) {
94832       {
94833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94834       };
94835     }
94836   }
94837
94838   jresult = (void *)result;
94839   return jresult;
94840 }
94841
94842
94843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94844   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94845   int arg2 ;
94846   Dali::Actor *arg3 = 0 ;
94847
94848   arg1 = (std::vector< Dali::Actor > *)jarg1;
94849   arg2 = (int)jarg2;
94850   arg3 = (Dali::Actor *)jarg3;
94851   if (!arg3) {
94852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94853     return ;
94854   }
94855   {
94856     try {
94857       try {
94858         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94859       }
94860       catch(std::out_of_range &_e) {
94861         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94862         return ;
94863       }
94864
94865     } catch (std::out_of_range& e) {
94866       {
94867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94868       };
94869     } catch (std::exception& e) {
94870       {
94871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94872       };
94873     } catch (Dali::DaliException e) {
94874       {
94875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94876       };
94877     } catch (...) {
94878       {
94879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94880       };
94881     }
94882   }
94883
94884 }
94885
94886
94887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94888   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94889   int arg2 ;
94890   std::vector< Dali::Actor > *arg3 = 0 ;
94891
94892   arg1 = (std::vector< Dali::Actor > *)jarg1;
94893   arg2 = (int)jarg2;
94894   arg3 = (std::vector< Dali::Actor > *)jarg3;
94895   if (!arg3) {
94896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94897     return ;
94898   }
94899   {
94900     try {
94901       try {
94902         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94903       }
94904       catch(std::out_of_range &_e) {
94905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94906         return ;
94907       }
94908
94909     } catch (std::out_of_range& e) {
94910       {
94911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94912       };
94913     } catch (std::exception& e) {
94914       {
94915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94916       };
94917     } catch (Dali::DaliException e) {
94918       {
94919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94920       };
94921     } catch (...) {
94922       {
94923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94924       };
94925     }
94926   }
94927
94928 }
94929
94930
94931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94932   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94933   int arg2 ;
94934
94935   arg1 = (std::vector< Dali::Actor > *)jarg1;
94936   arg2 = (int)jarg2;
94937   {
94938     try {
94939       try {
94940         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94941       }
94942       catch(std::out_of_range &_e) {
94943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94944         return ;
94945       }
94946
94947     } catch (std::out_of_range& e) {
94948       {
94949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94950       };
94951     } catch (std::exception& e) {
94952       {
94953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94954       };
94955     } catch (Dali::DaliException e) {
94956       {
94957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94958       };
94959     } catch (...) {
94960       {
94961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94962       };
94963     }
94964   }
94965
94966 }
94967
94968
94969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94970   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94971   int arg2 ;
94972   int arg3 ;
94973
94974   arg1 = (std::vector< Dali::Actor > *)jarg1;
94975   arg2 = (int)jarg2;
94976   arg3 = (int)jarg3;
94977   {
94978     try {
94979       try {
94980         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94981       }
94982       catch(std::out_of_range &_e) {
94983         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94984         return ;
94985       }
94986       catch(std::invalid_argument &_e) {
94987         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94988         return ;
94989       }
94990
94991     } catch (std::out_of_range& e) {
94992       {
94993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94994       };
94995     } catch (std::exception& e) {
94996       {
94997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94998       };
94999     } catch (Dali::DaliException e) {
95000       {
95001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95002       };
95003     } catch (...) {
95004       {
95005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95006       };
95007     }
95008   }
95009
95010 }
95011
95012
95013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95014   void * jresult ;
95015   Dali::Actor *arg1 = 0 ;
95016   int arg2 ;
95017   std::vector< Dali::Actor > *result = 0 ;
95018
95019   arg1 = (Dali::Actor *)jarg1;
95020   if (!arg1) {
95021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95022     return 0;
95023   }
95024   arg2 = (int)jarg2;
95025   {
95026     try {
95027       try {
95028         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95029       }
95030       catch(std::out_of_range &_e) {
95031         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95032         return 0;
95033       }
95034
95035     } catch (std::out_of_range& e) {
95036       {
95037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95038       };
95039     } catch (std::exception& e) {
95040       {
95041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95042       };
95043     } catch (Dali::DaliException e) {
95044       {
95045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95046       };
95047     } catch (...) {
95048       {
95049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95050       };
95051     }
95052   }
95053
95054   jresult = (void *)result;
95055   return jresult;
95056 }
95057
95058
95059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95060   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95061
95062   arg1 = (std::vector< Dali::Actor > *)jarg1;
95063   {
95064     try {
95065       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95066     } catch (std::out_of_range& e) {
95067       {
95068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95069       };
95070     } catch (std::exception& e) {
95071       {
95072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95073       };
95074     } catch (Dali::DaliException e) {
95075       {
95076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95077       };
95078     } catch (...) {
95079       {
95080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95081       };
95082     }
95083   }
95084
95085 }
95086
95087
95088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95089   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95090   int arg2 ;
95091   int arg3 ;
95092
95093   arg1 = (std::vector< Dali::Actor > *)jarg1;
95094   arg2 = (int)jarg2;
95095   arg3 = (int)jarg3;
95096   {
95097     try {
95098       try {
95099         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95100       }
95101       catch(std::out_of_range &_e) {
95102         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95103         return ;
95104       }
95105       catch(std::invalid_argument &_e) {
95106         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95107         return ;
95108       }
95109
95110     } catch (std::out_of_range& e) {
95111       {
95112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95113       };
95114     } catch (std::exception& e) {
95115       {
95116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95117       };
95118     } catch (Dali::DaliException e) {
95119       {
95120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95121       };
95122     } catch (...) {
95123       {
95124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95125       };
95126     }
95127   }
95128
95129 }
95130
95131
95132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95133   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95134   int arg2 ;
95135   std::vector< Dali::Actor > *arg3 = 0 ;
95136
95137   arg1 = (std::vector< Dali::Actor > *)jarg1;
95138   arg2 = (int)jarg2;
95139   arg3 = (std::vector< Dali::Actor > *)jarg3;
95140   if (!arg3) {
95141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95142     return ;
95143   }
95144   {
95145     try {
95146       try {
95147         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95148       }
95149       catch(std::out_of_range &_e) {
95150         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95151         return ;
95152       }
95153
95154     } catch (std::out_of_range& e) {
95155       {
95156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95157       };
95158     } catch (std::exception& e) {
95159       {
95160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95161       };
95162     } catch (Dali::DaliException e) {
95163       {
95164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95165       };
95166     } catch (...) {
95167       {
95168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95169       };
95170     }
95171   }
95172
95173 }
95174
95175
95176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95177   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95178
95179   arg1 = (std::vector< Dali::Actor > *)jarg1;
95180   {
95181     try {
95182       delete arg1;
95183     } catch (std::out_of_range& e) {
95184       {
95185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95186       };
95187     } catch (std::exception& e) {
95188       {
95189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95190       };
95191     } catch (Dali::DaliException e) {
95192       {
95193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95194       };
95195     } catch (...) {
95196       {
95197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95198       };
95199     }
95200   }
95201
95202 }
95203
95204
95205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95206   unsigned int jresult ;
95207   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95208   bool result;
95209
95210   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95211   {
95212     try {
95213       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95214     } catch (std::out_of_range& e) {
95215       {
95216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95217       };
95218     } catch (std::exception& e) {
95219       {
95220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95221       };
95222     } catch (Dali::DaliException e) {
95223       {
95224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95225       };
95226     } catch (...) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95229       };
95230     }
95231   }
95232
95233   jresult = result;
95234   return jresult;
95235 }
95236
95237
95238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95239   unsigned long jresult ;
95240   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95241   std::size_t result;
95242
95243   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95244   {
95245     try {
95246       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95247     } catch (std::out_of_range& e) {
95248       {
95249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95250       };
95251     } catch (std::exception& e) {
95252       {
95253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95254       };
95255     } catch (Dali::DaliException e) {
95256       {
95257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95258       };
95259     } catch (...) {
95260       {
95261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95262       };
95263     }
95264   }
95265
95266   jresult = (unsigned long)result;
95267   return jresult;
95268 }
95269
95270
95271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95272   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95273   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95274
95275   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95276   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95277   {
95278     try {
95279       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95280     } catch (std::out_of_range& e) {
95281       {
95282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95283       };
95284     } catch (std::exception& e) {
95285       {
95286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95287       };
95288     } catch (Dali::DaliException e) {
95289       {
95290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95291       };
95292     } catch (...) {
95293       {
95294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95295       };
95296     }
95297   }
95298
95299 }
95300
95301
95302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95303   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95304   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95305
95306   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95307   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95308   {
95309     try {
95310       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95311     } catch (std::out_of_range& e) {
95312       {
95313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95314       };
95315     } catch (std::exception& e) {
95316       {
95317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95318       };
95319     } catch (Dali::DaliException e) {
95320       {
95321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95322       };
95323     } catch (...) {
95324       {
95325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95326       };
95327     }
95328   }
95329
95330 }
95331
95332
95333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95334   unsigned int jresult ;
95335   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95336   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95337   bool result;
95338
95339   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95340   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95341   if (!arg2) {
95342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95343     return 0;
95344   }
95345   {
95346     try {
95347       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95348     } catch (std::out_of_range& e) {
95349       {
95350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95351       };
95352     } catch (std::exception& e) {
95353       {
95354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95355       };
95356     } catch (Dali::DaliException e) {
95357       {
95358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95359       };
95360     } catch (...) {
95361       {
95362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95363       };
95364     }
95365   }
95366
95367   jresult = result;
95368   return jresult;
95369 }
95370
95371
95372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95373   void * jresult ;
95374   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95375
95376   {
95377     try {
95378       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95379     } catch (std::out_of_range& e) {
95380       {
95381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95382       };
95383     } catch (std::exception& e) {
95384       {
95385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95386       };
95387     } catch (Dali::DaliException e) {
95388       {
95389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95390       };
95391     } catch (...) {
95392       {
95393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95394       };
95395     }
95396   }
95397
95398   jresult = (void *)result;
95399   return jresult;
95400 }
95401
95402
95403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95404   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95405
95406   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95407   {
95408     try {
95409       delete arg1;
95410     } catch (std::out_of_range& e) {
95411       {
95412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95413       };
95414     } catch (std::exception& e) {
95415       {
95416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95417       };
95418     } catch (Dali::DaliException e) {
95419       {
95420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95421       };
95422     } catch (...) {
95423       {
95424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95425       };
95426     }
95427   }
95428
95429 }
95430
95431
95432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95433   unsigned int jresult ;
95434   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95435   bool result;
95436
95437   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95438   {
95439     try {
95440       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);
95441     } catch (std::out_of_range& e) {
95442       {
95443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95444       };
95445     } catch (std::exception& e) {
95446       {
95447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95448       };
95449     } catch (Dali::DaliException e) {
95450       {
95451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95452       };
95453     } catch (...) {
95454       {
95455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95456       };
95457     }
95458   }
95459
95460   jresult = result;
95461   return jresult;
95462 }
95463
95464
95465 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95466   unsigned long jresult ;
95467   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95468   std::size_t result;
95469
95470   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95471   {
95472     try {
95473       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);
95474     } catch (std::out_of_range& e) {
95475       {
95476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95477       };
95478     } catch (std::exception& e) {
95479       {
95480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95481       };
95482     } catch (Dali::DaliException e) {
95483       {
95484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95485       };
95486     } catch (...) {
95487       {
95488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95489       };
95490     }
95491   }
95492
95493   jresult = (unsigned long)result;
95494   return jresult;
95495 }
95496
95497
95498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95499   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95500   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95501
95502   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95503   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95504   {
95505     try {
95506       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95507     } catch (std::out_of_range& e) {
95508       {
95509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95510       };
95511     } catch (std::exception& e) {
95512       {
95513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95514       };
95515     } catch (Dali::DaliException e) {
95516       {
95517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95518       };
95519     } catch (...) {
95520       {
95521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95522       };
95523     }
95524   }
95525
95526 }
95527
95528
95529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95530   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95531   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95532
95533   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95534   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95535   {
95536     try {
95537       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95538     } catch (std::out_of_range& e) {
95539       {
95540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95541       };
95542     } catch (std::exception& e) {
95543       {
95544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95545       };
95546     } catch (Dali::DaliException e) {
95547       {
95548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95549       };
95550     } catch (...) {
95551       {
95552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95553       };
95554     }
95555   }
95556
95557 }
95558
95559
95560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95561   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95562   Dali::Actor arg2 ;
95563   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95564   Dali::Actor *argp2 ;
95565
95566   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95567   argp2 = (Dali::Actor *)jarg2;
95568   if (!argp2) {
95569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95570     return ;
95571   }
95572   arg2 = *argp2;
95573   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95574   {
95575     try {
95576       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95577     } catch (std::out_of_range& e) {
95578       {
95579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95580       };
95581     } catch (std::exception& e) {
95582       {
95583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95584       };
95585     } catch (Dali::DaliException e) {
95586       {
95587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95588       };
95589     } catch (...) {
95590       {
95591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95592       };
95593     }
95594   }
95595
95596 }
95597
95598
95599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95600   void * jresult ;
95601   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95602
95603   {
95604     try {
95605       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95606     } catch (std::out_of_range& e) {
95607       {
95608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95609       };
95610     } catch (std::exception& e) {
95611       {
95612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95613       };
95614     } catch (Dali::DaliException e) {
95615       {
95616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95617       };
95618     } catch (...) {
95619       {
95620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95621       };
95622     }
95623   }
95624
95625   jresult = (void *)result;
95626   return jresult;
95627 }
95628
95629
95630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95631   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95632
95633   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95634   {
95635     try {
95636       delete arg1;
95637     } catch (std::out_of_range& e) {
95638       {
95639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95640       };
95641     } catch (std::exception& e) {
95642       {
95643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95644       };
95645     } catch (Dali::DaliException e) {
95646       {
95647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95648       };
95649     } catch (...) {
95650       {
95651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95652       };
95653     }
95654   }
95655
95656 }
95657
95658
95659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95660   unsigned int jresult ;
95661   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95662   bool result;
95663
95664   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95665   {
95666     try {
95667       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95668     } catch (std::out_of_range& e) {
95669       {
95670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95671       };
95672     } catch (std::exception& e) {
95673       {
95674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95675       };
95676     } catch (Dali::DaliException e) {
95677       {
95678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95679       };
95680     } catch (...) {
95681       {
95682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95683       };
95684     }
95685   }
95686
95687   jresult = result;
95688   return jresult;
95689 }
95690
95691
95692 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95693   unsigned long jresult ;
95694   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95695   std::size_t result;
95696
95697   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95698   {
95699     try {
95700       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95701     } catch (std::out_of_range& e) {
95702       {
95703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95704       };
95705     } catch (std::exception& e) {
95706       {
95707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95708       };
95709     } catch (Dali::DaliException e) {
95710       {
95711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95712       };
95713     } catch (...) {
95714       {
95715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95716       };
95717     }
95718   }
95719
95720   jresult = (unsigned long)result;
95721   return jresult;
95722 }
95723
95724
95725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95726   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95727   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95728
95729   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95730   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95731   {
95732     try {
95733       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95734     } catch (std::out_of_range& e) {
95735       {
95736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95737       };
95738     } catch (std::exception& e) {
95739       {
95740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95741       };
95742     } catch (Dali::DaliException e) {
95743       {
95744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95745       };
95746     } catch (...) {
95747       {
95748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95749       };
95750     }
95751   }
95752
95753 }
95754
95755
95756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95757   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95758   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95759
95760   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95761   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95762   {
95763     try {
95764       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95765     } catch (std::out_of_range& e) {
95766       {
95767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95768       };
95769     } catch (std::exception& e) {
95770       {
95771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95772       };
95773     } catch (Dali::DaliException e) {
95774       {
95775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95776       };
95777     } catch (...) {
95778       {
95779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95780       };
95781     }
95782   }
95783
95784 }
95785
95786
95787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95788   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95789   Dali::Actor arg2 ;
95790   Dali::Actor arg3 ;
95791   Dali::Actor *argp2 ;
95792   Dali::Actor *argp3 ;
95793
95794   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95795   argp2 = (Dali::Actor *)jarg2;
95796   if (!argp2) {
95797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95798     return ;
95799   }
95800   arg2 = *argp2;
95801   argp3 = (Dali::Actor *)jarg3;
95802   if (!argp3) {
95803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95804     return ;
95805   }
95806   arg3 = *argp3;
95807   {
95808     try {
95809       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95810     } catch (std::out_of_range& e) {
95811       {
95812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95813       };
95814     } catch (std::exception& e) {
95815       {
95816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95817       };
95818     } catch (Dali::DaliException e) {
95819       {
95820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95821       };
95822     } catch (...) {
95823       {
95824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95825       };
95826     }
95827   }
95828
95829 }
95830
95831
95832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95833   void * jresult ;
95834   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95835
95836   {
95837     try {
95838       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95839     } catch (std::out_of_range& e) {
95840       {
95841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95842       };
95843     } catch (std::exception& e) {
95844       {
95845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95846       };
95847     } catch (Dali::DaliException e) {
95848       {
95849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95850       };
95851     } catch (...) {
95852       {
95853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95854       };
95855     }
95856   }
95857
95858   jresult = (void *)result;
95859   return jresult;
95860 }
95861
95862
95863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95864   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95865
95866   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95867   {
95868     try {
95869       delete arg1;
95870     } catch (std::out_of_range& e) {
95871       {
95872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95873       };
95874     } catch (std::exception& e) {
95875       {
95876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95877       };
95878     } catch (Dali::DaliException e) {
95879       {
95880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95881       };
95882     } catch (...) {
95883       {
95884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95885       };
95886     }
95887   }
95888
95889 }
95890
95891
95892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95893   unsigned int jresult ;
95894   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95895   bool result;
95896
95897   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95898   {
95899     try {
95900       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95901     } catch (std::out_of_range& e) {
95902       {
95903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95904       };
95905     } catch (std::exception& e) {
95906       {
95907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95908       };
95909     } catch (Dali::DaliException e) {
95910       {
95911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95912       };
95913     } catch (...) {
95914       {
95915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95916       };
95917     }
95918   }
95919
95920   jresult = result;
95921   return jresult;
95922 }
95923
95924
95925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95926   unsigned long jresult ;
95927   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95928   std::size_t result;
95929
95930   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95931   {
95932     try {
95933       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95934     } catch (std::out_of_range& e) {
95935       {
95936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95937       };
95938     } catch (std::exception& e) {
95939       {
95940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95941       };
95942     } catch (Dali::DaliException e) {
95943       {
95944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95945       };
95946     } catch (...) {
95947       {
95948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95949       };
95950     }
95951   }
95952
95953   jresult = (unsigned long)result;
95954   return jresult;
95955 }
95956
95957
95958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95959   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95960   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95961
95962   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95963   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95964   {
95965     try {
95966       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95967     } catch (std::out_of_range& e) {
95968       {
95969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95970       };
95971     } catch (std::exception& e) {
95972       {
95973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95974       };
95975     } catch (Dali::DaliException e) {
95976       {
95977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95978       };
95979     } catch (...) {
95980       {
95981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95982       };
95983     }
95984   }
95985
95986 }
95987
95988
95989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95990   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95991   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95992
95993   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95994   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95995   {
95996     try {
95997       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95998     } catch (std::out_of_range& e) {
95999       {
96000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96001       };
96002     } catch (std::exception& e) {
96003       {
96004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96005       };
96006     } catch (Dali::DaliException e) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96009       };
96010     } catch (...) {
96011       {
96012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96013       };
96014     }
96015   }
96016
96017 }
96018
96019
96020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96021   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96022   Dali::Actor arg2 ;
96023   bool arg3 ;
96024   Dali::Actor *argp2 ;
96025
96026   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96027   argp2 = (Dali::Actor *)jarg2;
96028   if (!argp2) {
96029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96030     return ;
96031   }
96032   arg2 = *argp2;
96033   arg3 = jarg3 ? true : false;
96034   {
96035     try {
96036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96037     } catch (std::out_of_range& e) {
96038       {
96039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96040       };
96041     } catch (std::exception& e) {
96042       {
96043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96044       };
96045     } catch (Dali::DaliException e) {
96046       {
96047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96048       };
96049     } catch (...) {
96050       {
96051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96052       };
96053     }
96054   }
96055
96056 }
96057
96058
96059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96060   void * jresult ;
96061   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96062
96063   {
96064     try {
96065       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96066     } catch (std::out_of_range& e) {
96067       {
96068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96069       };
96070     } catch (std::exception& e) {
96071       {
96072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96073       };
96074     } catch (Dali::DaliException e) {
96075       {
96076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96077       };
96078     } catch (...) {
96079       {
96080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96081       };
96082     }
96083   }
96084
96085   jresult = (void *)result;
96086   return jresult;
96087 }
96088
96089
96090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96091   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96092
96093   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96094   {
96095     try {
96096       delete arg1;
96097     } catch (std::out_of_range& e) {
96098       {
96099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96100       };
96101     } catch (std::exception& e) {
96102       {
96103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96104       };
96105     } catch (Dali::DaliException e) {
96106       {
96107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96108       };
96109     } catch (...) {
96110       {
96111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96112       };
96113     }
96114   }
96115
96116 }
96117
96118
96119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96120   unsigned int jresult ;
96121   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96122   bool result;
96123
96124   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96125   {
96126     try {
96127       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);
96128     } catch (std::out_of_range& e) {
96129       {
96130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96131       };
96132     } catch (std::exception& e) {
96133       {
96134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96135       };
96136     } catch (Dali::DaliException e) {
96137       {
96138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96139       };
96140     } catch (...) {
96141       {
96142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96143       };
96144     }
96145   }
96146
96147   jresult = result;
96148   return jresult;
96149 }
96150
96151
96152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96153   unsigned long jresult ;
96154   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96155   std::size_t result;
96156
96157   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96158   {
96159     try {
96160       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);
96161     } catch (std::out_of_range& e) {
96162       {
96163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96164       };
96165     } catch (std::exception& e) {
96166       {
96167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96168       };
96169     } catch (Dali::DaliException e) {
96170       {
96171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96172       };
96173     } catch (...) {
96174       {
96175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96176       };
96177     }
96178   }
96179
96180   jresult = (unsigned long)result;
96181   return jresult;
96182 }
96183
96184
96185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96186   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96187   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96188
96189   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96190   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96191   {
96192     try {
96193       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96194     } catch (std::out_of_range& e) {
96195       {
96196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96197       };
96198     } catch (std::exception& e) {
96199       {
96200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96201       };
96202     } catch (Dali::DaliException e) {
96203       {
96204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96205       };
96206     } catch (...) {
96207       {
96208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96209       };
96210     }
96211   }
96212
96213 }
96214
96215
96216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96217   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96218   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96219
96220   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96221   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96222   {
96223     try {
96224       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96225     } catch (std::out_of_range& e) {
96226       {
96227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96228       };
96229     } catch (std::exception& e) {
96230       {
96231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96232       };
96233     } catch (Dali::DaliException e) {
96234       {
96235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96236       };
96237     } catch (...) {
96238       {
96239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96240       };
96241     }
96242   }
96243
96244 }
96245
96246
96247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96248   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96249   Dali::Toolkit::StyleManager arg2 ;
96250   Dali::StyleChange::Type arg3 ;
96251   Dali::Toolkit::StyleManager *argp2 ;
96252
96253   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96254   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96255   if (!argp2) {
96256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96257     return ;
96258   }
96259   arg2 = *argp2;
96260   arg3 = (Dali::StyleChange::Type)jarg3;
96261   {
96262     try {
96263       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96264     } catch (std::out_of_range& e) {
96265       {
96266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96267       };
96268     } catch (std::exception& e) {
96269       {
96270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96271       };
96272     } catch (Dali::DaliException e) {
96273       {
96274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96275       };
96276     } catch (...) {
96277       {
96278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96279       };
96280     }
96281   }
96282
96283 }
96284
96285
96286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96287   void * jresult ;
96288   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96289
96290   {
96291     try {
96292       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96293     } catch (std::out_of_range& e) {
96294       {
96295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96296       };
96297     } catch (std::exception& e) {
96298       {
96299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96300       };
96301     } catch (Dali::DaliException e) {
96302       {
96303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96304       };
96305     } catch (...) {
96306       {
96307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96308       };
96309     }
96310   }
96311
96312   jresult = (void *)result;
96313   return jresult;
96314 }
96315
96316
96317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96318   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96319
96320   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96321   {
96322     try {
96323       delete arg1;
96324     } catch (std::out_of_range& e) {
96325       {
96326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96327       };
96328     } catch (std::exception& e) {
96329       {
96330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96331       };
96332     } catch (Dali::DaliException e) {
96333       {
96334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96335       };
96336     } catch (...) {
96337       {
96338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96339       };
96340     }
96341   }
96342
96343 }
96344
96345
96346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96347   unsigned int jresult ;
96348   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96349   bool result;
96350
96351   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96352   {
96353     try {
96354       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96355     } catch (std::out_of_range& e) {
96356       {
96357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96358       };
96359     } catch (std::exception& e) {
96360       {
96361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96362       };
96363     } catch (Dali::DaliException e) {
96364       {
96365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96366       };
96367     } catch (...) {
96368       {
96369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96370       };
96371     }
96372   }
96373
96374   jresult = result;
96375   return jresult;
96376 }
96377
96378
96379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96380   unsigned long jresult ;
96381   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96382   std::size_t result;
96383
96384   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96385   {
96386     try {
96387       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96388     } catch (std::out_of_range& e) {
96389       {
96390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96391       };
96392     } catch (std::exception& e) {
96393       {
96394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96395       };
96396     } catch (Dali::DaliException e) {
96397       {
96398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96399       };
96400     } catch (...) {
96401       {
96402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96403       };
96404     }
96405   }
96406
96407   jresult = (unsigned long)result;
96408   return jresult;
96409 }
96410
96411
96412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96413   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96414   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96415
96416   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96417   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96418   {
96419     try {
96420       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96421     } catch (std::out_of_range& e) {
96422       {
96423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96424       };
96425     } catch (std::exception& e) {
96426       {
96427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96428       };
96429     } catch (Dali::DaliException e) {
96430       {
96431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96432       };
96433     } catch (...) {
96434       {
96435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96436       };
96437     }
96438   }
96439
96440 }
96441
96442
96443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96444   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96445   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96446
96447   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96448   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96449   {
96450     try {
96451       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96452     } catch (std::out_of_range& e) {
96453       {
96454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96455       };
96456     } catch (std::exception& e) {
96457       {
96458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96459       };
96460     } catch (Dali::DaliException e) {
96461       {
96462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96463       };
96464     } catch (...) {
96465       {
96466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96467       };
96468     }
96469   }
96470
96471 }
96472
96473
96474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96475   unsigned int jresult ;
96476   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96477   Dali::Toolkit::Button arg2 ;
96478   Dali::Toolkit::Button *argp2 ;
96479   bool result;
96480
96481   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96482   argp2 = (Dali::Toolkit::Button *)jarg2;
96483   if (!argp2) {
96484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96485     return 0;
96486   }
96487   arg2 = *argp2;
96488   {
96489     try {
96490       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96491     } catch (std::out_of_range& e) {
96492       {
96493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96494       };
96495     } catch (std::exception& e) {
96496       {
96497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96498       };
96499     } catch (Dali::DaliException e) {
96500       {
96501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96502       };
96503     } catch (...) {
96504       {
96505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96506       };
96507     }
96508   }
96509
96510   jresult = result;
96511   return jresult;
96512 }
96513
96514
96515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96516   void * jresult ;
96517   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96518
96519   {
96520     try {
96521       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96522     } catch (std::out_of_range& e) {
96523       {
96524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96525       };
96526     } catch (std::exception& e) {
96527       {
96528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96529       };
96530     } catch (Dali::DaliException e) {
96531       {
96532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96533       };
96534     } catch (...) {
96535       {
96536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96537       };
96538     }
96539   }
96540
96541   jresult = (void *)result;
96542   return jresult;
96543 }
96544
96545
96546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96547   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96548
96549   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96550   {
96551     try {
96552       delete arg1;
96553     } catch (std::out_of_range& e) {
96554       {
96555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96556       };
96557     } catch (std::exception& e) {
96558       {
96559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96560       };
96561     } catch (Dali::DaliException e) {
96562       {
96563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96564       };
96565     } catch (...) {
96566       {
96567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96568       };
96569     }
96570   }
96571
96572 }
96573
96574
96575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96576   unsigned int jresult ;
96577   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96578   bool result;
96579
96580   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96581   {
96582     try {
96583       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96584     } catch (std::out_of_range& e) {
96585       {
96586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96587       };
96588     } catch (std::exception& e) {
96589       {
96590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96591       };
96592     } catch (Dali::DaliException e) {
96593       {
96594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96595       };
96596     } catch (...) {
96597       {
96598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96599       };
96600     }
96601   }
96602
96603   jresult = result;
96604   return jresult;
96605 }
96606
96607
96608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96609   unsigned long jresult ;
96610   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96611   std::size_t result;
96612
96613   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96614   {
96615     try {
96616       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96617     } catch (std::out_of_range& e) {
96618       {
96619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96620       };
96621     } catch (std::exception& e) {
96622       {
96623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96624       };
96625     } catch (Dali::DaliException e) {
96626       {
96627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96628       };
96629     } catch (...) {
96630       {
96631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96632       };
96633     }
96634   }
96635
96636   jresult = (unsigned long)result;
96637   return jresult;
96638 }
96639
96640
96641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96642   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96643   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96644
96645   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96646   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96647   {
96648     try {
96649       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96650     } catch (std::out_of_range& e) {
96651       {
96652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96653       };
96654     } catch (std::exception& e) {
96655       {
96656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96657       };
96658     } catch (Dali::DaliException e) {
96659       {
96660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96661       };
96662     } catch (...) {
96663       {
96664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96665       };
96666     }
96667   }
96668
96669 }
96670
96671
96672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96673   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96674   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96675
96676   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96677   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96678   {
96679     try {
96680       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96681     } catch (std::out_of_range& e) {
96682       {
96683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96684       };
96685     } catch (std::exception& e) {
96686       {
96687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96688       };
96689     } catch (Dali::DaliException e) {
96690       {
96691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96692       };
96693     } catch (...) {
96694       {
96695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96696       };
96697     }
96698   }
96699
96700 }
96701
96702
96703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96704   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96705   Dali::Toolkit::GaussianBlurView arg2 ;
96706   Dali::Toolkit::GaussianBlurView *argp2 ;
96707
96708   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96709   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96710   if (!argp2) {
96711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96712     return ;
96713   }
96714   arg2 = *argp2;
96715   {
96716     try {
96717       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96718     } catch (std::out_of_range& e) {
96719       {
96720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96721       };
96722     } catch (std::exception& e) {
96723       {
96724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96725       };
96726     } catch (Dali::DaliException e) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96729       };
96730     } catch (...) {
96731       {
96732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96733       };
96734     }
96735   }
96736
96737 }
96738
96739
96740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96741   void * jresult ;
96742   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96743
96744   {
96745     try {
96746       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96747     } catch (std::out_of_range& e) {
96748       {
96749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96750       };
96751     } catch (std::exception& e) {
96752       {
96753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96754       };
96755     } catch (Dali::DaliException e) {
96756       {
96757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96758       };
96759     } catch (...) {
96760       {
96761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96762       };
96763     }
96764   }
96765
96766   jresult = (void *)result;
96767   return jresult;
96768 }
96769
96770
96771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96772   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96773
96774   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96775   {
96776     try {
96777       delete arg1;
96778     } catch (std::out_of_range& e) {
96779       {
96780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96781       };
96782     } catch (std::exception& e) {
96783       {
96784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96785       };
96786     } catch (Dali::DaliException e) {
96787       {
96788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96789       };
96790     } catch (...) {
96791       {
96792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96793       };
96794     }
96795   }
96796
96797 }
96798
96799
96800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96801   unsigned int jresult ;
96802   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96803   bool result;
96804
96805   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96806   {
96807     try {
96808       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);
96809     } catch (std::out_of_range& e) {
96810       {
96811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96812       };
96813     } catch (std::exception& e) {
96814       {
96815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96816       };
96817     } catch (Dali::DaliException e) {
96818       {
96819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96820       };
96821     } catch (...) {
96822       {
96823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96824       };
96825     }
96826   }
96827
96828   jresult = result;
96829   return jresult;
96830 }
96831
96832
96833 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96834   unsigned long jresult ;
96835   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96836   std::size_t result;
96837
96838   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96839   {
96840     try {
96841       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);
96842     } catch (std::out_of_range& e) {
96843       {
96844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96845       };
96846     } catch (std::exception& e) {
96847       {
96848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96849       };
96850     } catch (Dali::DaliException e) {
96851       {
96852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96853       };
96854     } catch (...) {
96855       {
96856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96857       };
96858     }
96859   }
96860
96861   jresult = (unsigned long)result;
96862   return jresult;
96863 }
96864
96865
96866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96867   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96868   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96869
96870   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96871   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96872   {
96873     try {
96874       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96875     } catch (std::out_of_range& e) {
96876       {
96877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96878       };
96879     } catch (std::exception& e) {
96880       {
96881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96882       };
96883     } catch (Dali::DaliException e) {
96884       {
96885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96886       };
96887     } catch (...) {
96888       {
96889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96890       };
96891     }
96892   }
96893
96894 }
96895
96896
96897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96898   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96899   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96900
96901   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96902   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96903   {
96904     try {
96905       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96906     } catch (std::out_of_range& e) {
96907       {
96908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96909       };
96910     } catch (std::exception& e) {
96911       {
96912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96913       };
96914     } catch (Dali::DaliException e) {
96915       {
96916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96917       };
96918     } catch (...) {
96919       {
96920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96921       };
96922     }
96923   }
96924
96925 }
96926
96927
96928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96929   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96930   Dali::Toolkit::PageTurnView arg2 ;
96931   unsigned int arg3 ;
96932   bool arg4 ;
96933   Dali::Toolkit::PageTurnView *argp2 ;
96934
96935   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96936   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96937   if (!argp2) {
96938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96939     return ;
96940   }
96941   arg2 = *argp2;
96942   arg3 = (unsigned int)jarg3;
96943   arg4 = jarg4 ? true : false;
96944   {
96945     try {
96946       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96947     } catch (std::out_of_range& e) {
96948       {
96949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96950       };
96951     } catch (std::exception& e) {
96952       {
96953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96954       };
96955     } catch (Dali::DaliException e) {
96956       {
96957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96958       };
96959     } catch (...) {
96960       {
96961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96962       };
96963     }
96964   }
96965
96966 }
96967
96968
96969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96970   void * jresult ;
96971   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96972
96973   {
96974     try {
96975       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96976     } catch (std::out_of_range& e) {
96977       {
96978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96979       };
96980     } catch (std::exception& e) {
96981       {
96982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96983       };
96984     } catch (Dali::DaliException e) {
96985       {
96986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96987       };
96988     } catch (...) {
96989       {
96990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96991       };
96992     }
96993   }
96994
96995   jresult = (void *)result;
96996   return jresult;
96997 }
96998
96999
97000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97001   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97002
97003   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97004   {
97005     try {
97006       delete arg1;
97007     } catch (std::out_of_range& e) {
97008       {
97009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97010       };
97011     } catch (std::exception& e) {
97012       {
97013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97014       };
97015     } catch (Dali::DaliException e) {
97016       {
97017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97018       };
97019     } catch (...) {
97020       {
97021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97022       };
97023     }
97024   }
97025
97026 }
97027
97028
97029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97030   unsigned int jresult ;
97031   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97032   bool result;
97033
97034   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97035   {
97036     try {
97037       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97038     } catch (std::out_of_range& e) {
97039       {
97040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97041       };
97042     } catch (std::exception& e) {
97043       {
97044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97045       };
97046     } catch (Dali::DaliException e) {
97047       {
97048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97049       };
97050     } catch (...) {
97051       {
97052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97053       };
97054     }
97055   }
97056
97057   jresult = result;
97058   return jresult;
97059 }
97060
97061
97062 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97063   unsigned long jresult ;
97064   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97065   std::size_t result;
97066
97067   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97068   {
97069     try {
97070       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97071     } catch (std::out_of_range& e) {
97072       {
97073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97074       };
97075     } catch (std::exception& e) {
97076       {
97077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97078       };
97079     } catch (Dali::DaliException e) {
97080       {
97081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97082       };
97083     } catch (...) {
97084       {
97085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97086       };
97087     }
97088   }
97089
97090   jresult = (unsigned long)result;
97091   return jresult;
97092 }
97093
97094
97095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97096   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97097   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97098
97099   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97100   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97101   {
97102     try {
97103       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97104     } catch (std::out_of_range& e) {
97105       {
97106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97107       };
97108     } catch (std::exception& e) {
97109       {
97110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97111       };
97112     } catch (Dali::DaliException e) {
97113       {
97114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97115       };
97116     } catch (...) {
97117       {
97118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97119       };
97120     }
97121   }
97122
97123 }
97124
97125
97126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97127   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97128   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97129
97130   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97131   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97132   {
97133     try {
97134       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97135     } catch (std::out_of_range& e) {
97136       {
97137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97138       };
97139     } catch (std::exception& e) {
97140       {
97141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97142       };
97143     } catch (Dali::DaliException e) {
97144       {
97145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97146       };
97147     } catch (...) {
97148       {
97149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97150       };
97151     }
97152   }
97153
97154 }
97155
97156
97157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97158   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97159   Dali::Toolkit::PageTurnView arg2 ;
97160   Dali::Toolkit::PageTurnView *argp2 ;
97161
97162   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97163   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97164   if (!argp2) {
97165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97166     return ;
97167   }
97168   arg2 = *argp2;
97169   {
97170     try {
97171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97172     } catch (std::out_of_range& e) {
97173       {
97174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97175       };
97176     } catch (std::exception& e) {
97177       {
97178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97179       };
97180     } catch (Dali::DaliException e) {
97181       {
97182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97183       };
97184     } catch (...) {
97185       {
97186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97187       };
97188     }
97189   }
97190
97191 }
97192
97193
97194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97195   void * jresult ;
97196   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97197
97198   {
97199     try {
97200       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97201     } catch (std::out_of_range& e) {
97202       {
97203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97204       };
97205     } catch (std::exception& e) {
97206       {
97207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97208       };
97209     } catch (Dali::DaliException e) {
97210       {
97211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97212       };
97213     } catch (...) {
97214       {
97215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97216       };
97217     }
97218   }
97219
97220   jresult = (void *)result;
97221   return jresult;
97222 }
97223
97224
97225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97226   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97227
97228   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97229   {
97230     try {
97231       delete arg1;
97232     } catch (std::out_of_range& e) {
97233       {
97234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97235       };
97236     } catch (std::exception& e) {
97237       {
97238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97239       };
97240     } catch (Dali::DaliException e) {
97241       {
97242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97243       };
97244     } catch (...) {
97245       {
97246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97247       };
97248     }
97249   }
97250
97251 }
97252
97253
97254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97255   unsigned int jresult ;
97256   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97257   bool result;
97258
97259   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97260   {
97261     try {
97262       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);
97263     } catch (std::out_of_range& e) {
97264       {
97265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97266       };
97267     } catch (std::exception& e) {
97268       {
97269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97270       };
97271     } catch (Dali::DaliException e) {
97272       {
97273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97274       };
97275     } catch (...) {
97276       {
97277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97278       };
97279     }
97280   }
97281
97282   jresult = result;
97283   return jresult;
97284 }
97285
97286
97287 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97288   unsigned long jresult ;
97289   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97290   std::size_t result;
97291
97292   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97293   {
97294     try {
97295       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);
97296     } catch (std::out_of_range& e) {
97297       {
97298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97299       };
97300     } catch (std::exception& e) {
97301       {
97302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97303       };
97304     } catch (Dali::DaliException e) {
97305       {
97306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97307       };
97308     } catch (...) {
97309       {
97310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97311       };
97312     }
97313   }
97314
97315   jresult = (unsigned long)result;
97316   return jresult;
97317 }
97318
97319
97320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97321   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97322   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97323
97324   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97325   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97326   {
97327     try {
97328       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97329     } catch (std::out_of_range& e) {
97330       {
97331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97332       };
97333     } catch (std::exception& e) {
97334       {
97335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97336       };
97337     } catch (Dali::DaliException e) {
97338       {
97339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97340       };
97341     } catch (...) {
97342       {
97343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97344       };
97345     }
97346   }
97347
97348 }
97349
97350
97351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97352   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97353   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97354
97355   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97356   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97357   {
97358     try {
97359       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97360     } catch (std::out_of_range& e) {
97361       {
97362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97363       };
97364     } catch (std::exception& e) {
97365       {
97366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97367       };
97368     } catch (Dali::DaliException e) {
97369       {
97370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97371       };
97372     } catch (...) {
97373       {
97374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97375       };
97376     }
97377   }
97378
97379 }
97380
97381
97382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97383   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97384   Dali::Toolkit::ProgressBar arg2 ;
97385   float arg3 ;
97386   float arg4 ;
97387   Dali::Toolkit::ProgressBar *argp2 ;
97388
97389   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97390   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97391   if (!argp2) {
97392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97393     return ;
97394   }
97395   arg2 = *argp2;
97396   arg3 = (float)jarg3;
97397   arg4 = (float)jarg4;
97398   {
97399     try {
97400       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97401     } catch (std::out_of_range& e) {
97402       {
97403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97404       };
97405     } catch (std::exception& e) {
97406       {
97407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97408       };
97409     } catch (Dali::DaliException e) {
97410       {
97411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97412       };
97413     } catch (...) {
97414       {
97415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97416       };
97417     }
97418   }
97419
97420 }
97421
97422
97423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97424   void * jresult ;
97425   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97426
97427   {
97428     try {
97429       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97430     } catch (std::out_of_range& e) {
97431       {
97432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97433       };
97434     } catch (std::exception& e) {
97435       {
97436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97437       };
97438     } catch (Dali::DaliException e) {
97439       {
97440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97441       };
97442     } catch (...) {
97443       {
97444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97445       };
97446     }
97447   }
97448
97449   jresult = (void *)result;
97450   return jresult;
97451 }
97452
97453
97454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97455   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97456
97457   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97458   {
97459     try {
97460       delete arg1;
97461     } catch (std::out_of_range& e) {
97462       {
97463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97464       };
97465     } catch (std::exception& e) {
97466       {
97467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97468       };
97469     } catch (Dali::DaliException e) {
97470       {
97471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97472       };
97473     } catch (...) {
97474       {
97475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97476       };
97477     }
97478   }
97479
97480 }
97481
97482
97483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97484   unsigned int jresult ;
97485   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97486   bool result;
97487
97488   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97489   {
97490     try {
97491       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);
97492     } catch (std::out_of_range& e) {
97493       {
97494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97495       };
97496     } catch (std::exception& e) {
97497       {
97498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97499       };
97500     } catch (Dali::DaliException e) {
97501       {
97502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97503       };
97504     } catch (...) {
97505       {
97506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97507       };
97508     }
97509   }
97510
97511   jresult = result;
97512   return jresult;
97513 }
97514
97515
97516 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97517   unsigned long jresult ;
97518   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97519   std::size_t result;
97520
97521   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97522   {
97523     try {
97524       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);
97525     } catch (std::out_of_range& e) {
97526       {
97527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97528       };
97529     } catch (std::exception& e) {
97530       {
97531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97532       };
97533     } catch (Dali::DaliException e) {
97534       {
97535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97536       };
97537     } catch (...) {
97538       {
97539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97540       };
97541     }
97542   }
97543
97544   jresult = (unsigned long)result;
97545   return jresult;
97546 }
97547
97548
97549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97550   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97551   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97552
97553   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97554   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97555   {
97556     try {
97557       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97558     } catch (std::out_of_range& e) {
97559       {
97560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97561       };
97562     } catch (std::exception& e) {
97563       {
97564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97565       };
97566     } catch (Dali::DaliException e) {
97567       {
97568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97569       };
97570     } catch (...) {
97571       {
97572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97573       };
97574     }
97575   }
97576
97577 }
97578
97579
97580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97581   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97582   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97583
97584   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97585   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97586   {
97587     try {
97588       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97589     } catch (std::out_of_range& e) {
97590       {
97591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97592       };
97593     } catch (std::exception& e) {
97594       {
97595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97596       };
97597     } catch (Dali::DaliException e) {
97598       {
97599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97600       };
97601     } catch (...) {
97602       {
97603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97604       };
97605     }
97606   }
97607
97608 }
97609
97610
97611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97612   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97613   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97614
97615   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97616   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97617   if (!arg2) {
97618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97619     return ;
97620   }
97621   {
97622     try {
97623       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97624     } catch (std::out_of_range& e) {
97625       {
97626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97627       };
97628     } catch (std::exception& e) {
97629       {
97630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97631       };
97632     } catch (Dali::DaliException e) {
97633       {
97634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97635       };
97636     } catch (...) {
97637       {
97638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97639       };
97640     }
97641   }
97642
97643 }
97644
97645
97646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97647   void * jresult ;
97648   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97649
97650   {
97651     try {
97652       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97653     } catch (std::out_of_range& e) {
97654       {
97655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97656       };
97657     } catch (std::exception& e) {
97658       {
97659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97660       };
97661     } catch (Dali::DaliException e) {
97662       {
97663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97664       };
97665     } catch (...) {
97666       {
97667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97668       };
97669     }
97670   }
97671
97672   jresult = (void *)result;
97673   return jresult;
97674 }
97675
97676
97677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97678   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97679
97680   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97681   {
97682     try {
97683       delete arg1;
97684     } catch (std::out_of_range& e) {
97685       {
97686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97687       };
97688     } catch (std::exception& e) {
97689       {
97690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97691       };
97692     } catch (Dali::DaliException e) {
97693       {
97694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97695       };
97696     } catch (...) {
97697       {
97698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97699       };
97700     }
97701   }
97702
97703 }
97704
97705
97706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97707   unsigned int jresult ;
97708   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97709   bool result;
97710
97711   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97712   {
97713     try {
97714       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97715     } catch (std::out_of_range& e) {
97716       {
97717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97718       };
97719     } catch (std::exception& e) {
97720       {
97721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97722       };
97723     } catch (Dali::DaliException e) {
97724       {
97725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97726       };
97727     } catch (...) {
97728       {
97729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97730       };
97731     }
97732   }
97733
97734   jresult = result;
97735   return jresult;
97736 }
97737
97738
97739 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97740   unsigned long jresult ;
97741   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97742   std::size_t result;
97743
97744   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97745   {
97746     try {
97747       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97748     } catch (std::out_of_range& e) {
97749       {
97750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97751       };
97752     } catch (std::exception& e) {
97753       {
97754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97755       };
97756     } catch (Dali::DaliException e) {
97757       {
97758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97759       };
97760     } catch (...) {
97761       {
97762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97763       };
97764     }
97765   }
97766
97767   jresult = (unsigned long)result;
97768   return jresult;
97769 }
97770
97771
97772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97773   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97774   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97775
97776   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97777   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97778   {
97779     try {
97780       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97781     } catch (std::out_of_range& e) {
97782       {
97783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97784       };
97785     } catch (std::exception& e) {
97786       {
97787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97788       };
97789     } catch (Dali::DaliException e) {
97790       {
97791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97792       };
97793     } catch (...) {
97794       {
97795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97796       };
97797     }
97798   }
97799
97800 }
97801
97802
97803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97804   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97805   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97806
97807   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97808   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97809   {
97810     try {
97811       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97812     } catch (std::out_of_range& e) {
97813       {
97814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97815       };
97816     } catch (std::exception& e) {
97817       {
97818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97819       };
97820     } catch (Dali::DaliException e) {
97821       {
97822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97823       };
97824     } catch (...) {
97825       {
97826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97827       };
97828     }
97829   }
97830
97831 }
97832
97833
97834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97835   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97836   Dali::Vector2 *arg2 = 0 ;
97837
97838   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97839   arg2 = (Dali::Vector2 *)jarg2;
97840   if (!arg2) {
97841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97842     return ;
97843   }
97844   {
97845     try {
97846       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97847     } catch (std::out_of_range& e) {
97848       {
97849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97850       };
97851     } catch (std::exception& e) {
97852       {
97853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97854       };
97855     } catch (Dali::DaliException e) {
97856       {
97857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97858       };
97859     } catch (...) {
97860       {
97861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97862       };
97863     }
97864   }
97865
97866 }
97867
97868
97869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97870   void * jresult ;
97871   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97872
97873   {
97874     try {
97875       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97876     } catch (std::out_of_range& e) {
97877       {
97878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97879       };
97880     } catch (std::exception& e) {
97881       {
97882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97883       };
97884     } catch (Dali::DaliException e) {
97885       {
97886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97887       };
97888     } catch (...) {
97889       {
97890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97891       };
97892     }
97893   }
97894
97895   jresult = (void *)result;
97896   return jresult;
97897 }
97898
97899
97900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97901   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97902
97903   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97904   {
97905     try {
97906       delete arg1;
97907     } catch (std::out_of_range& e) {
97908       {
97909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97910       };
97911     } catch (std::exception& e) {
97912       {
97913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97914       };
97915     } catch (Dali::DaliException e) {
97916       {
97917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97918       };
97919     } catch (...) {
97920       {
97921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97922       };
97923     }
97924   }
97925
97926 }
97927
97928
97929
97930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97931   unsigned int jresult ;
97932   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97933   bool result;
97934
97935   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97936   {
97937     try {
97938       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);
97939     } catch (std::out_of_range& e) {
97940       {
97941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97942       };
97943     } catch (std::exception& e) {
97944       {
97945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97946       };
97947     } catch (Dali::DaliException e) {
97948       {
97949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97950       };
97951     } catch (...) {
97952       {
97953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97954       };
97955     }
97956   }
97957
97958   jresult = result;
97959   return jresult;
97960 }
97961
97962
97963 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97964   unsigned long jresult ;
97965   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97966   std::size_t result;
97967
97968   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97969   {
97970     try {
97971       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);
97972     } catch (std::out_of_range& e) {
97973       {
97974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97975       };
97976     } catch (std::exception& e) {
97977       {
97978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97979       };
97980     } catch (Dali::DaliException e) {
97981       {
97982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97983       };
97984     } catch (...) {
97985       {
97986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97987       };
97988     }
97989   }
97990
97991   jresult = (unsigned long)result;
97992   return jresult;
97993 }
97994
97995
97996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97997   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97998   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97999
98000   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98001   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98002   {
98003     try {
98004       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98005     } catch (std::out_of_range& e) {
98006       {
98007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98008       };
98009     } catch (std::exception& e) {
98010       {
98011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98012       };
98013     } catch (Dali::DaliException e) {
98014       {
98015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98016       };
98017     } catch (...) {
98018       {
98019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98020       };
98021     }
98022   }
98023
98024 }
98025
98026
98027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98028   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98029   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98030
98031   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98032   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98033   {
98034     try {
98035       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98036     } catch (std::out_of_range& e) {
98037       {
98038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98039       };
98040     } catch (std::exception& e) {
98041       {
98042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98043       };
98044     } catch (Dali::DaliException e) {
98045       {
98046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98047       };
98048     } catch (...) {
98049       {
98050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98051       };
98052     }
98053   }
98054
98055 }
98056
98057
98058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98059   unsigned int jresult ;
98060   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98061   Dali::Toolkit::Control arg2 ;
98062   Dali::KeyEvent *arg3 = 0 ;
98063   Dali::Toolkit::Control *argp2 ;
98064   bool result;
98065
98066   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98067   argp2 = (Dali::Toolkit::Control *)jarg2;
98068   if (!argp2) {
98069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98070     return 0;
98071   }
98072   arg2 = *argp2;
98073   arg3 = (Dali::KeyEvent *)jarg3;
98074   if (!arg3) {
98075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98076     return 0;
98077   }
98078   {
98079     try {
98080       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);
98081     } catch (std::out_of_range& e) {
98082       {
98083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98084       };
98085     } catch (std::exception& e) {
98086       {
98087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98088       };
98089     } catch (Dali::DaliException e) {
98090       {
98091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98092       };
98093     } catch (...) {
98094       {
98095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98096       };
98097     }
98098   }
98099
98100   jresult = result;
98101   return jresult;
98102 }
98103
98104
98105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98106   void * jresult ;
98107   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98108
98109   {
98110     try {
98111       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98112     } catch (std::out_of_range& e) {
98113       {
98114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98115       };
98116     } catch (std::exception& e) {
98117       {
98118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98119       };
98120     } catch (Dali::DaliException e) {
98121       {
98122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98123       };
98124     } catch (...) {
98125       {
98126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98127       };
98128     }
98129   }
98130
98131   jresult = (void *)result;
98132   return jresult;
98133 }
98134
98135
98136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98137   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98138
98139   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98140   {
98141     try {
98142       delete arg1;
98143     } catch (std::out_of_range& e) {
98144       {
98145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98146       };
98147     } catch (std::exception& e) {
98148       {
98149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98150       };
98151     } catch (Dali::DaliException e) {
98152       {
98153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98154       };
98155     } catch (...) {
98156       {
98157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98158       };
98159     }
98160   }
98161
98162 }
98163
98164
98165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98166   unsigned int jresult ;
98167   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98168   bool result;
98169
98170   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98171   {
98172     try {
98173       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98174     } catch (std::out_of_range& e) {
98175       {
98176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98177       };
98178     } catch (std::exception& e) {
98179       {
98180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98181       };
98182     } catch (Dali::DaliException e) {
98183       {
98184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98185       };
98186     } catch (...) {
98187       {
98188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98189       };
98190     }
98191   }
98192
98193   jresult = result;
98194   return jresult;
98195 }
98196
98197
98198 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98199   unsigned long jresult ;
98200   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98201   std::size_t result;
98202
98203   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98204   {
98205     try {
98206       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98207     } catch (std::out_of_range& e) {
98208       {
98209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98210       };
98211     } catch (std::exception& e) {
98212       {
98213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98214       };
98215     } catch (Dali::DaliException e) {
98216       {
98217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98218       };
98219     } catch (...) {
98220       {
98221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98222       };
98223     }
98224   }
98225
98226   jresult = (unsigned long)result;
98227   return jresult;
98228 }
98229
98230
98231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98232   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98233   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98234
98235   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98236   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98237   {
98238     try {
98239       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98240     } catch (std::out_of_range& e) {
98241       {
98242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98243       };
98244     } catch (std::exception& e) {
98245       {
98246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98247       };
98248     } catch (Dali::DaliException e) {
98249       {
98250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98251       };
98252     } catch (...) {
98253       {
98254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98255       };
98256     }
98257   }
98258
98259 }
98260
98261
98262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98263   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98264   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98265
98266   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98267   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98268   {
98269     try {
98270       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98271     } catch (std::out_of_range& e) {
98272       {
98273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98274       };
98275     } catch (std::exception& e) {
98276       {
98277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98278       };
98279     } catch (Dali::DaliException e) {
98280       {
98281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98282       };
98283     } catch (...) {
98284       {
98285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98286       };
98287     }
98288   }
98289
98290 }
98291
98292
98293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98294   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98295   Dali::Toolkit::Control arg2 ;
98296   Dali::Toolkit::Control *argp2 ;
98297
98298   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98299   argp2 = (Dali::Toolkit::Control *)jarg2;
98300   if (!argp2) {
98301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98302     return ;
98303   }
98304   arg2 = *argp2;
98305   {
98306     try {
98307       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98308     } catch (std::out_of_range& e) {
98309       {
98310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98311       };
98312     } catch (std::exception& e) {
98313       {
98314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98315       };
98316     } catch (Dali::DaliException e) {
98317       {
98318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98319       };
98320     } catch (...) {
98321       {
98322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98323       };
98324     }
98325   }
98326
98327 }
98328
98329
98330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98331   void * jresult ;
98332   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98333
98334   {
98335     try {
98336       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98337     } catch (std::out_of_range& e) {
98338       {
98339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98340       };
98341     } catch (std::exception& e) {
98342       {
98343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98344       };
98345     } catch (Dali::DaliException e) {
98346       {
98347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98348       };
98349     } catch (...) {
98350       {
98351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98352       };
98353     }
98354   }
98355
98356   jresult = (void *)result;
98357   return jresult;
98358 }
98359
98360
98361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98362   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98363
98364   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98365   {
98366     try {
98367       delete arg1;
98368     } catch (std::out_of_range& e) {
98369       {
98370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98371       };
98372     } catch (std::exception& e) {
98373       {
98374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98375       };
98376     } catch (Dali::DaliException e) {
98377       {
98378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98379       };
98380     } catch (...) {
98381       {
98382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98383       };
98384     }
98385   }
98386
98387 }
98388
98389
98390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98391   unsigned int jresult ;
98392   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98393   bool result;
98394
98395   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98396   {
98397     try {
98398       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98399     } catch (std::out_of_range& e) {
98400       {
98401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98402       };
98403     } catch (std::exception& e) {
98404       {
98405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98406       };
98407     } catch (Dali::DaliException e) {
98408       {
98409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98410       };
98411     } catch (...) {
98412       {
98413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98414       };
98415     }
98416   }
98417
98418   jresult = result;
98419   return jresult;
98420 }
98421
98422
98423 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98424   unsigned long jresult ;
98425   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98426   std::size_t result;
98427
98428   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98429   {
98430     try {
98431       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98432     } catch (std::out_of_range& e) {
98433       {
98434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98435       };
98436     } catch (std::exception& e) {
98437       {
98438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98439       };
98440     } catch (Dali::DaliException e) {
98441       {
98442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98443       };
98444     } catch (...) {
98445       {
98446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98447       };
98448     }
98449   }
98450
98451   jresult = (unsigned long)result;
98452   return jresult;
98453 }
98454
98455
98456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98457   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98458   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98459
98460   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98461   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98462   {
98463     try {
98464       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98465     } catch (std::out_of_range& e) {
98466       {
98467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98468       };
98469     } catch (std::exception& e) {
98470       {
98471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98472       };
98473     } catch (Dali::DaliException e) {
98474       {
98475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98476       };
98477     } catch (...) {
98478       {
98479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98480       };
98481     }
98482   }
98483
98484 }
98485
98486
98487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98488   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98489   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98490
98491   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98492   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98493   {
98494     try {
98495       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98496     } catch (std::out_of_range& e) {
98497       {
98498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98499       };
98500     } catch (std::exception& e) {
98501       {
98502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98503       };
98504     } catch (Dali::DaliException e) {
98505       {
98506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98507       };
98508     } catch (...) {
98509       {
98510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98511       };
98512     }
98513   }
98514
98515 }
98516
98517
98518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98519   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98520   Dali::Toolkit::VideoView *arg2 = 0 ;
98521
98522   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98523   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98524   if (!arg2) {
98525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98526     return ;
98527   }
98528   {
98529     try {
98530       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98531     } catch (std::out_of_range& e) {
98532       {
98533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98534       };
98535     } catch (std::exception& e) {
98536       {
98537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98538       };
98539     } catch (Dali::DaliException e) {
98540       {
98541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98542       };
98543     } catch (...) {
98544       {
98545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98546       };
98547     }
98548   }
98549
98550 }
98551
98552
98553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98554   void * jresult ;
98555   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98556
98557   {
98558     try {
98559       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98560     } catch (std::out_of_range& e) {
98561       {
98562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98563       };
98564     } catch (std::exception& e) {
98565       {
98566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98567       };
98568     } catch (Dali::DaliException e) {
98569       {
98570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98571       };
98572     } catch (...) {
98573       {
98574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98575       };
98576     }
98577   }
98578
98579   jresult = (void *)result;
98580   return jresult;
98581 }
98582
98583
98584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98585   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98586
98587   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98588   {
98589     try {
98590       delete arg1;
98591     } catch (std::out_of_range& e) {
98592       {
98593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98594       };
98595     } catch (std::exception& e) {
98596       {
98597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98598       };
98599     } catch (Dali::DaliException e) {
98600       {
98601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98602       };
98603     } catch (...) {
98604       {
98605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98606       };
98607     }
98608   }
98609
98610 }
98611
98612
98613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98614   unsigned int jresult ;
98615   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98616   bool result;
98617
98618   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98619   {
98620     try {
98621       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98622     } catch (std::out_of_range& e) {
98623       {
98624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98625       };
98626     } catch (std::exception& e) {
98627       {
98628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98629       };
98630     } catch (Dali::DaliException e) {
98631       {
98632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98633       };
98634     } catch (...) {
98635       {
98636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98637       };
98638     }
98639   }
98640
98641   jresult = result;
98642   return jresult;
98643 }
98644
98645
98646 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98647   unsigned long jresult ;
98648   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98649   std::size_t result;
98650
98651   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98652   {
98653     try {
98654       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98655     } catch (std::out_of_range& e) {
98656       {
98657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98658       };
98659     } catch (std::exception& e) {
98660       {
98661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98662       };
98663     } catch (Dali::DaliException e) {
98664       {
98665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98666       };
98667     } catch (...) {
98668       {
98669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98670       };
98671     }
98672   }
98673
98674   jresult = (unsigned long)result;
98675   return jresult;
98676 }
98677
98678
98679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98680   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98681   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98682
98683   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98684   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98685   {
98686     try {
98687       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98688     } catch (std::out_of_range& e) {
98689       {
98690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98691       };
98692     } catch (std::exception& e) {
98693       {
98694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98695       };
98696     } catch (Dali::DaliException e) {
98697       {
98698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98699       };
98700     } catch (...) {
98701       {
98702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98703       };
98704     }
98705   }
98706
98707 }
98708
98709
98710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98711   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98712   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98713
98714   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98715   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98716   {
98717     try {
98718       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98719     } catch (std::out_of_range& e) {
98720       {
98721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98722       };
98723     } catch (std::exception& e) {
98724       {
98725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98726       };
98727     } catch (Dali::DaliException e) {
98728       {
98729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98730       };
98731     } catch (...) {
98732       {
98733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98734       };
98735     }
98736   }
98737
98738 }
98739
98740
98741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98742   unsigned int jresult ;
98743   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98744   Dali::Toolkit::Slider arg2 ;
98745   float arg3 ;
98746   Dali::Toolkit::Slider *argp2 ;
98747   bool result;
98748
98749   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98750   argp2 = (Dali::Toolkit::Slider *)jarg2;
98751   if (!argp2) {
98752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98753     return 0;
98754   }
98755   arg2 = *argp2;
98756   arg3 = (float)jarg3;
98757   {
98758     try {
98759       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98760     } catch (std::out_of_range& e) {
98761       {
98762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98763       };
98764     } catch (std::exception& e) {
98765       {
98766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98767       };
98768     } catch (Dali::DaliException e) {
98769       {
98770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98771       };
98772     } catch (...) {
98773       {
98774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98775       };
98776     }
98777   }
98778
98779   jresult = result;
98780   return jresult;
98781 }
98782
98783
98784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98785   void * jresult ;
98786   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98787
98788   {
98789     try {
98790       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98791     } catch (std::out_of_range& e) {
98792       {
98793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98794       };
98795     } catch (std::exception& e) {
98796       {
98797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98798       };
98799     } catch (Dali::DaliException e) {
98800       {
98801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98802       };
98803     } catch (...) {
98804       {
98805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98806       };
98807     }
98808   }
98809
98810   jresult = (void *)result;
98811   return jresult;
98812 }
98813
98814
98815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98816   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98817
98818   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98819   {
98820     try {
98821       delete arg1;
98822     } catch (std::out_of_range& e) {
98823       {
98824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98825       };
98826     } catch (std::exception& e) {
98827       {
98828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98829       };
98830     } catch (Dali::DaliException e) {
98831       {
98832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98833       };
98834     } catch (...) {
98835       {
98836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98837       };
98838     }
98839   }
98840
98841 }
98842
98843
98844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98845   unsigned int jresult ;
98846   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98847   bool result;
98848
98849   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98850   {
98851     try {
98852       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98853     } catch (std::out_of_range& e) {
98854       {
98855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98856       };
98857     } catch (std::exception& e) {
98858       {
98859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98860       };
98861     } catch (Dali::DaliException e) {
98862       {
98863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98864       };
98865     } catch (...) {
98866       {
98867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98868       };
98869     }
98870   }
98871
98872   jresult = result;
98873   return jresult;
98874 }
98875
98876
98877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98878   unsigned long jresult ;
98879   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98880   std::size_t result;
98881
98882   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98883   {
98884     try {
98885       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98886     } catch (std::out_of_range& e) {
98887       {
98888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98889       };
98890     } catch (std::exception& e) {
98891       {
98892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98893       };
98894     } catch (Dali::DaliException e) {
98895       {
98896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98897       };
98898     } catch (...) {
98899       {
98900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98901       };
98902     }
98903   }
98904
98905   jresult = (unsigned long)result;
98906   return jresult;
98907 }
98908
98909
98910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98911   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98912   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98913
98914   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98915   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98916   {
98917     try {
98918       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98919     } catch (std::out_of_range& e) {
98920       {
98921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98922       };
98923     } catch (std::exception& e) {
98924       {
98925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98926       };
98927     } catch (Dali::DaliException e) {
98928       {
98929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98930       };
98931     } catch (...) {
98932       {
98933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98934       };
98935     }
98936   }
98937
98938 }
98939
98940
98941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98942   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98943   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98944
98945   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98946   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98947   {
98948     try {
98949       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98950     } catch (std::out_of_range& e) {
98951       {
98952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98953       };
98954     } catch (std::exception& e) {
98955       {
98956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98957       };
98958     } catch (Dali::DaliException e) {
98959       {
98960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98961       };
98962     } catch (...) {
98963       {
98964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98965       };
98966     }
98967   }
98968
98969 }
98970
98971
98972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98973   unsigned int jresult ;
98974   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98975   Dali::Toolkit::Slider arg2 ;
98976   int arg3 ;
98977   Dali::Toolkit::Slider *argp2 ;
98978   bool result;
98979
98980   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98981   argp2 = (Dali::Toolkit::Slider *)jarg2;
98982   if (!argp2) {
98983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98984     return 0;
98985   }
98986   arg2 = *argp2;
98987   arg3 = (int)jarg3;
98988   {
98989     try {
98990       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98991     } catch (std::out_of_range& e) {
98992       {
98993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98994       };
98995     } catch (std::exception& e) {
98996       {
98997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98998       };
98999     } catch (Dali::DaliException e) {
99000       {
99001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99002       };
99003     } catch (...) {
99004       {
99005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99006       };
99007     }
99008   }
99009
99010   jresult = result;
99011   return jresult;
99012 }
99013
99014
99015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99016   void * jresult ;
99017   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99018
99019   {
99020     try {
99021       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99022     } catch (std::out_of_range& e) {
99023       {
99024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99025       };
99026     } catch (std::exception& e) {
99027       {
99028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99029       };
99030     } catch (Dali::DaliException e) {
99031       {
99032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99033       };
99034     } catch (...) {
99035       {
99036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99037       };
99038     }
99039   }
99040
99041   jresult = (void *)result;
99042   return jresult;
99043 }
99044
99045
99046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99047   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99048
99049   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99050   {
99051     try {
99052       delete arg1;
99053     } catch (std::out_of_range& e) {
99054       {
99055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99056       };
99057     } catch (std::exception& e) {
99058       {
99059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99060       };
99061     } catch (Dali::DaliException e) {
99062       {
99063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99064       };
99065     } catch (...) {
99066       {
99067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99068       };
99069     }
99070   }
99071
99072 }
99073
99074
99075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99076   void * jresult ;
99077   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99078
99079   {
99080     try {
99081       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99082     } catch (std::out_of_range& e) {
99083       {
99084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99085       };
99086     } catch (std::exception& e) {
99087       {
99088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99089       };
99090     } catch (Dali::DaliException e) {
99091       {
99092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99093       };
99094     } catch (...) {
99095       {
99096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99097       };
99098     }
99099   }
99100
99101   jresult = (void *)result;
99102   return jresult;
99103 }
99104
99105
99106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99107   void * jresult ;
99108   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99109   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99110
99111   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99112   {
99113     try {
99114       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99115     } catch (std::out_of_range& e) {
99116       {
99117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99118       };
99119     } catch (std::exception& e) {
99120       {
99121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99122       };
99123     } catch (Dali::DaliException e) {
99124       {
99125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99126       };
99127     } catch (...) {
99128       {
99129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99130       };
99131     }
99132   }
99133
99134   jresult = (void *)result;
99135   return jresult;
99136 }
99137
99138
99139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99140   void * jresult ;
99141   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99142   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99143
99144   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99145   if (!arg1) {
99146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99147     return 0;
99148   }
99149   {
99150     try {
99151       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99152     } catch (std::out_of_range& e) {
99153       {
99154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99155       };
99156     } catch (std::exception& e) {
99157       {
99158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99159       };
99160     } catch (Dali::DaliException e) {
99161       {
99162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99163       };
99164     } catch (...) {
99165       {
99166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99167       };
99168     }
99169   }
99170
99171   jresult = (void *)result;
99172   return jresult;
99173 }
99174
99175
99176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99177   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99178
99179   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99180   {
99181     try {
99182       delete arg1;
99183     } catch (std::out_of_range& e) {
99184       {
99185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99186       };
99187     } catch (std::exception& e) {
99188       {
99189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99190       };
99191     } catch (Dali::DaliException e) {
99192       {
99193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99194       };
99195     } catch (...) {
99196       {
99197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99198       };
99199     }
99200   }
99201
99202 }
99203
99204
99205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99206   void * jresult ;
99207   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99208   Dali::Toolkit::Ruler *result = 0 ;
99209
99210   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99211   {
99212     try {
99213       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99214     } catch (std::out_of_range& e) {
99215       {
99216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99217       };
99218     } catch (std::exception& e) {
99219       {
99220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99221       };
99222     } catch (Dali::DaliException e) {
99223       {
99224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99225       };
99226     } catch (...) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99229       };
99230     }
99231   }
99232
99233   jresult = (void *)result;
99234   return jresult;
99235 }
99236
99237
99238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99239   void * jresult ;
99240   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99241   Dali::Toolkit::Ruler *result = 0 ;
99242
99243   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99244   {
99245     try {
99246       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99247     } catch (std::out_of_range& e) {
99248       {
99249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99250       };
99251     } catch (std::exception& e) {
99252       {
99253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99254       };
99255     } catch (Dali::DaliException e) {
99256       {
99257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99258       };
99259     } catch (...) {
99260       {
99261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99262       };
99263     }
99264   }
99265
99266   jresult = (void *)result;
99267   return jresult;
99268 }
99269
99270
99271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99272   void * jresult ;
99273   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99274   Dali::Toolkit::Ruler *result = 0 ;
99275
99276   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99277   {
99278     try {
99279       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99280     } catch (std::out_of_range& e) {
99281       {
99282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99283       };
99284     } catch (std::exception& e) {
99285       {
99286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99287       };
99288     } catch (Dali::DaliException e) {
99289       {
99290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99291       };
99292     } catch (...) {
99293       {
99294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99295       };
99296     }
99297   }
99298
99299   jresult = (void *)result;
99300   return jresult;
99301 }
99302
99303
99304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99305   void * jresult ;
99306   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99307   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99308   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99309
99310   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99311   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99312   if (!arg2) {
99313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99314     return 0;
99315   }
99316   {
99317     try {
99318       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99319     } catch (std::out_of_range& e) {
99320       {
99321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99322       };
99323     } catch (std::exception& e) {
99324       {
99325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99326       };
99327     } catch (Dali::DaliException e) {
99328       {
99329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99330       };
99331     } catch (...) {
99332       {
99333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99334       };
99335     }
99336   }
99337
99338   jresult = (void *)result;
99339   return jresult;
99340 }
99341
99342
99343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99344   void * jresult ;
99345   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99346   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99347   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99348
99349   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99350   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99351   {
99352     try {
99353       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99354     } catch (std::out_of_range& e) {
99355       {
99356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99357       };
99358     } catch (std::exception& e) {
99359       {
99360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99361       };
99362     } catch (Dali::DaliException e) {
99363       {
99364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99365       };
99366     } catch (...) {
99367       {
99368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99369       };
99370     }
99371   }
99372
99373   jresult = (void *)result;
99374   return jresult;
99375 }
99376
99377
99378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99379   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99380
99381   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99382   {
99383     try {
99384       (arg1)->Reset();
99385     } catch (std::out_of_range& e) {
99386       {
99387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99388       };
99389     } catch (std::exception& e) {
99390       {
99391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99392       };
99393     } catch (Dali::DaliException e) {
99394       {
99395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99396       };
99397     } catch (...) {
99398       {
99399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99400       };
99401     }
99402   }
99403
99404 }
99405
99406
99407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99408   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99409   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99410
99411   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99412   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99413   {
99414     try {
99415       (arg1)->Reset(arg2);
99416     } catch (std::out_of_range& e) {
99417       {
99418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99419       };
99420     } catch (std::exception& e) {
99421       {
99422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99423       };
99424     } catch (Dali::DaliException e) {
99425       {
99426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99427       };
99428     } catch (...) {
99429       {
99430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99431       };
99432     }
99433   }
99434
99435 }
99436
99437
99438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99439   void * jresult ;
99440   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99441   Dali::Toolkit::Ruler *result = 0 ;
99442
99443   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99444   {
99445     try {
99446       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99447     } catch (std::out_of_range& e) {
99448       {
99449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99450       };
99451     } catch (std::exception& e) {
99452       {
99453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99454       };
99455     } catch (Dali::DaliException e) {
99456       {
99457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99458       };
99459     } catch (...) {
99460       {
99461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99462       };
99463     }
99464   }
99465
99466   jresult = (void *)result;
99467   return jresult;
99468 }
99469
99470
99471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99472   float jresult ;
99473   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99474   float arg2 ;
99475   float arg3 ;
99476   float result;
99477
99478   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99479   arg2 = (float)jarg2;
99480   arg3 = (float)jarg3;
99481   {
99482     try {
99483       result = (float)(*arg1)->Snap(arg2,arg3);
99484     } catch (std::out_of_range& e) {
99485       {
99486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99487       };
99488     } catch (std::exception& e) {
99489       {
99490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99491       };
99492     } catch (Dali::DaliException e) {
99493       {
99494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99495       };
99496     } catch (...) {
99497       {
99498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99499       };
99500     }
99501   }
99502
99503   jresult = result;
99504   return jresult;
99505 }
99506
99507
99508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99509   float jresult ;
99510   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99511   float arg2 ;
99512   float result;
99513
99514   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99515   arg2 = (float)jarg2;
99516   {
99517     try {
99518       result = (float)(*arg1)->Snap(arg2);
99519     } catch (std::out_of_range& e) {
99520       {
99521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99522       };
99523     } catch (std::exception& e) {
99524       {
99525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99526       };
99527     } catch (Dali::DaliException e) {
99528       {
99529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99530       };
99531     } catch (...) {
99532       {
99533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99534       };
99535     }
99536   }
99537
99538   jresult = result;
99539   return jresult;
99540 }
99541
99542
99543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99544   float jresult ;
99545   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99546   unsigned int arg2 ;
99547   unsigned int *arg3 = 0 ;
99548   bool arg4 ;
99549   float result;
99550
99551   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99552   arg2 = (unsigned int)jarg2;
99553   arg3 = (unsigned int *)jarg3;
99554   arg4 = jarg4 ? true : false;
99555   {
99556     try {
99557       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99558     } catch (std::out_of_range& e) {
99559       {
99560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99561       };
99562     } catch (std::exception& e) {
99563       {
99564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99565       };
99566     } catch (Dali::DaliException e) {
99567       {
99568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99569       };
99570     } catch (...) {
99571       {
99572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99573       };
99574     }
99575   }
99576
99577   jresult = result;
99578   return jresult;
99579 }
99580
99581
99582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99583   unsigned int jresult ;
99584   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99585   float arg2 ;
99586   bool arg3 ;
99587   unsigned int result;
99588
99589   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99590   arg2 = (float)jarg2;
99591   arg3 = jarg3 ? true : false;
99592   {
99593     try {
99594       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99595     } catch (std::out_of_range& e) {
99596       {
99597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99598       };
99599     } catch (std::exception& e) {
99600       {
99601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99602       };
99603     } catch (Dali::DaliException e) {
99604       {
99605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99606       };
99607     } catch (...) {
99608       {
99609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99610       };
99611     }
99612   }
99613
99614   jresult = result;
99615   return jresult;
99616 }
99617
99618
99619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99620   unsigned int jresult ;
99621   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99622   unsigned int result;
99623
99624   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99625   {
99626     try {
99627       result = (unsigned int)(*arg1)->GetTotalPages();
99628     } catch (std::out_of_range& e) {
99629       {
99630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99631       };
99632     } catch (std::exception& e) {
99633       {
99634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99635       };
99636     } catch (Dali::DaliException e) {
99637       {
99638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99639       };
99640     } catch (...) {
99641       {
99642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99643       };
99644     }
99645   }
99646
99647   jresult = result;
99648   return jresult;
99649 }
99650
99651
99652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99653   int jresult ;
99654   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99655   Dali::Toolkit::Ruler::RulerType result;
99656
99657   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99658   {
99659     try {
99660       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99661     } catch (std::out_of_range& e) {
99662       {
99663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99664       };
99665     } catch (std::exception& e) {
99666       {
99667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99668       };
99669     } catch (Dali::DaliException e) {
99670       {
99671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99672       };
99673     } catch (...) {
99674       {
99675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99676       };
99677     }
99678   }
99679
99680   jresult = (int)result;
99681   return jresult;
99682 }
99683
99684
99685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99686   unsigned int jresult ;
99687   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99688   bool result;
99689
99690   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99691   {
99692     try {
99693       result = (bool)(*arg1)->IsEnabled();
99694     } catch (std::out_of_range& e) {
99695       {
99696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99697       };
99698     } catch (std::exception& e) {
99699       {
99700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99701       };
99702     } catch (Dali::DaliException e) {
99703       {
99704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99705       };
99706     } catch (...) {
99707       {
99708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99709       };
99710     }
99711   }
99712
99713   jresult = result;
99714   return jresult;
99715 }
99716
99717
99718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99719   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99720
99721   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99722   {
99723     try {
99724       (*arg1)->Enable();
99725     } catch (std::out_of_range& e) {
99726       {
99727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99728       };
99729     } catch (std::exception& e) {
99730       {
99731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99732       };
99733     } catch (Dali::DaliException e) {
99734       {
99735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99736       };
99737     } catch (...) {
99738       {
99739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99740       };
99741     }
99742   }
99743
99744 }
99745
99746
99747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99748   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99749
99750   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99751   {
99752     try {
99753       (*arg1)->Disable();
99754     } catch (std::out_of_range& e) {
99755       {
99756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99757       };
99758     } catch (std::exception& e) {
99759       {
99760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99761       };
99762     } catch (Dali::DaliException e) {
99763       {
99764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99765       };
99766     } catch (...) {
99767       {
99768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99769       };
99770     }
99771   }
99772
99773 }
99774
99775
99776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99777   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99778   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99779   Dali::Toolkit::RulerDomain *argp2 ;
99780
99781   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99782   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99783   if (!argp2) {
99784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99785     return ;
99786   }
99787   arg2 = *argp2;
99788   {
99789     try {
99790       (*arg1)->SetDomain(arg2);
99791     } catch (std::out_of_range& e) {
99792       {
99793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99794       };
99795     } catch (std::exception& e) {
99796       {
99797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99798       };
99799     } catch (Dali::DaliException e) {
99800       {
99801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99802       };
99803     } catch (...) {
99804       {
99805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99806       };
99807     }
99808   }
99809
99810 }
99811
99812
99813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99814   void * jresult ;
99815   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99816   Dali::Toolkit::RulerDomain *result = 0 ;
99817
99818   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99819   {
99820     try {
99821       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99822     } catch (std::out_of_range& e) {
99823       {
99824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99825       };
99826     } catch (std::exception& e) {
99827       {
99828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99829       };
99830     } catch (Dali::DaliException e) {
99831       {
99832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99833       };
99834     } catch (...) {
99835       {
99836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99837       };
99838     }
99839   }
99840
99841   jresult = (void *)result;
99842   return jresult;
99843 }
99844
99845
99846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99847   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99848
99849   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99850   {
99851     try {
99852       (*arg1)->DisableDomain();
99853     } catch (std::out_of_range& e) {
99854       {
99855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99856       };
99857     } catch (std::exception& e) {
99858       {
99859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99860       };
99861     } catch (Dali::DaliException e) {
99862       {
99863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99864       };
99865     } catch (...) {
99866       {
99867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99868       };
99869     }
99870   }
99871
99872 }
99873
99874
99875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99876   float jresult ;
99877   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99878   float arg2 ;
99879   float arg3 ;
99880   float arg4 ;
99881   float result;
99882
99883   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99884   arg2 = (float)jarg2;
99885   arg3 = (float)jarg3;
99886   arg4 = (float)jarg4;
99887   {
99888     try {
99889       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99890     } catch (std::out_of_range& e) {
99891       {
99892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99893       };
99894     } catch (std::exception& e) {
99895       {
99896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99897       };
99898     } catch (Dali::DaliException e) {
99899       {
99900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99901       };
99902     } catch (...) {
99903       {
99904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99905       };
99906     }
99907   }
99908
99909   jresult = result;
99910   return jresult;
99911 }
99912
99913
99914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99915   float jresult ;
99916   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99917   float arg2 ;
99918   float arg3 ;
99919   float result;
99920
99921   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99922   arg2 = (float)jarg2;
99923   arg3 = (float)jarg3;
99924   {
99925     try {
99926       result = (float)(*arg1)->Clamp(arg2,arg3);
99927     } catch (std::out_of_range& e) {
99928       {
99929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99930       };
99931     } catch (std::exception& e) {
99932       {
99933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99934       };
99935     } catch (Dali::DaliException e) {
99936       {
99937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99938       };
99939     } catch (...) {
99940       {
99941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99942       };
99943     }
99944   }
99945
99946   jresult = result;
99947   return jresult;
99948 }
99949
99950
99951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99952   float jresult ;
99953   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99954   float arg2 ;
99955   float result;
99956
99957   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99958   arg2 = (float)jarg2;
99959   {
99960     try {
99961       result = (float)(*arg1)->Clamp(arg2);
99962     } catch (std::out_of_range& e) {
99963       {
99964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99965       };
99966     } catch (std::exception& e) {
99967       {
99968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99969       };
99970     } catch (Dali::DaliException e) {
99971       {
99972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99973       };
99974     } catch (...) {
99975       {
99976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99977       };
99978     }
99979   }
99980
99981   jresult = result;
99982   return jresult;
99983 }
99984
99985
99986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99987   float jresult ;
99988   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99989   float arg2 ;
99990   float arg3 ;
99991   float arg4 ;
99992   Dali::Toolkit::ClampState *arg5 = 0 ;
99993   float result;
99994
99995   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99996   arg2 = (float)jarg2;
99997   arg3 = (float)jarg3;
99998   arg4 = (float)jarg4;
99999   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100000   if (!arg5) {
100001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100002     return 0;
100003   }
100004   {
100005     try {
100006       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100007     } catch (std::out_of_range& e) {
100008       {
100009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100010       };
100011     } catch (std::exception& e) {
100012       {
100013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100014       };
100015     } catch (Dali::DaliException e) {
100016       {
100017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100018       };
100019     } catch (...) {
100020       {
100021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100022       };
100023     }
100024   }
100025
100026   jresult = result;
100027   return jresult;
100028 }
100029
100030
100031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100032   float jresult ;
100033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100034   float arg2 ;
100035   float arg3 ;
100036   float arg4 ;
100037   float arg5 ;
100038   float result;
100039
100040   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100041   arg2 = (float)jarg2;
100042   arg3 = (float)jarg3;
100043   arg4 = (float)jarg4;
100044   arg5 = (float)jarg5;
100045   {
100046     try {
100047       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100048     } catch (std::out_of_range& e) {
100049       {
100050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100051       };
100052     } catch (std::exception& e) {
100053       {
100054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100055       };
100056     } catch (Dali::DaliException e) {
100057       {
100058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100059       };
100060     } catch (...) {
100061       {
100062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100063       };
100064     }
100065   }
100066
100067   jresult = result;
100068   return jresult;
100069 }
100070
100071
100072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100073   float jresult ;
100074   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100075   float arg2 ;
100076   float arg3 ;
100077   float arg4 ;
100078   float result;
100079
100080   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100081   arg2 = (float)jarg2;
100082   arg3 = (float)jarg3;
100083   arg4 = (float)jarg4;
100084   {
100085     try {
100086       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100087     } catch (std::out_of_range& e) {
100088       {
100089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100090       };
100091     } catch (std::exception& e) {
100092       {
100093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100094       };
100095     } catch (Dali::DaliException e) {
100096       {
100097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100098       };
100099     } catch (...) {
100100       {
100101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100102       };
100103     }
100104   }
100105
100106   jresult = result;
100107   return jresult;
100108 }
100109
100110
100111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100112   float jresult ;
100113   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100114   float arg2 ;
100115   float arg3 ;
100116   float result;
100117
100118   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100119   arg2 = (float)jarg2;
100120   arg3 = (float)jarg3;
100121   {
100122     try {
100123       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100124     } catch (std::out_of_range& e) {
100125       {
100126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100127       };
100128     } catch (std::exception& e) {
100129       {
100130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100131       };
100132     } catch (Dali::DaliException e) {
100133       {
100134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100135       };
100136     } catch (...) {
100137       {
100138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100139       };
100140     }
100141   }
100142
100143   jresult = result;
100144   return jresult;
100145 }
100146
100147
100148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100149   float jresult ;
100150   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100151   float arg2 ;
100152   float result;
100153
100154   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100155   arg2 = (float)jarg2;
100156   {
100157     try {
100158       result = (float)(*arg1)->SnapAndClamp(arg2);
100159     } catch (std::out_of_range& e) {
100160       {
100161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100162       };
100163     } catch (std::exception& e) {
100164       {
100165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100166       };
100167     } catch (Dali::DaliException e) {
100168       {
100169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100170       };
100171     } catch (...) {
100172       {
100173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100174       };
100175     }
100176   }
100177
100178   jresult = result;
100179   return jresult;
100180 }
100181
100182
100183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100184   float jresult ;
100185   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100186   float arg2 ;
100187   float arg3 ;
100188   float arg4 ;
100189   float arg5 ;
100190   Dali::Toolkit::ClampState *arg6 = 0 ;
100191   float result;
100192
100193   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100194   arg2 = (float)jarg2;
100195   arg3 = (float)jarg3;
100196   arg4 = (float)jarg4;
100197   arg5 = (float)jarg5;
100198   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100199   if (!arg6) {
100200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100201     return 0;
100202   }
100203   {
100204     try {
100205       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100206     } catch (std::out_of_range& e) {
100207       {
100208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100209       };
100210     } catch (std::exception& e) {
100211       {
100212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100213       };
100214     } catch (Dali::DaliException e) {
100215       {
100216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100217       };
100218     } catch (...) {
100219       {
100220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100221       };
100222     }
100223   }
100224
100225   jresult = result;
100226   return jresult;
100227 }
100228
100229
100230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100232
100233   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100234   {
100235     try {
100236       (*arg1)->Reference();
100237     } catch (std::out_of_range& e) {
100238       {
100239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100240       };
100241     } catch (std::exception& e) {
100242       {
100243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100244       };
100245     } catch (Dali::DaliException e) {
100246       {
100247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100248       };
100249     } catch (...) {
100250       {
100251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100252       };
100253     }
100254   }
100255
100256 }
100257
100258
100259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100260   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100261
100262   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100263   {
100264     try {
100265       (*arg1)->Unreference();
100266     } catch (std::out_of_range& e) {
100267       {
100268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100269       };
100270     } catch (std::exception& e) {
100271       {
100272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100273       };
100274     } catch (Dali::DaliException e) {
100275       {
100276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100277       };
100278     } catch (...) {
100279       {
100280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100281       };
100282     }
100283   }
100284
100285 }
100286
100287
100288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100289   int jresult ;
100290   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100291   int result;
100292
100293   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100294   {
100295     try {
100296       result = (int)(*arg1)->ReferenceCount();
100297     } catch (std::out_of_range& e) {
100298       {
100299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100300       };
100301     } catch (std::exception& e) {
100302       {
100303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100304       };
100305     } catch (Dali::DaliException e) {
100306       {
100307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100308       };
100309     } catch (...) {
100310       {
100311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100312       };
100313     }
100314   }
100315
100316   jresult = result;
100317   return jresult;
100318 }
100319
100320
100321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100322   unsigned int jresult ;
100323   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100324   bool result;
100325
100326   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100327   {
100328     try {
100329       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100330     } catch (std::out_of_range& e) {
100331       {
100332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100333       };
100334     } catch (std::exception& e) {
100335       {
100336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100337       };
100338     } catch (Dali::DaliException e) {
100339       {
100340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100341       };
100342     } catch (...) {
100343       {
100344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100345       };
100346     }
100347   }
100348
100349   jresult = result;
100350   return jresult;
100351 }
100352
100353
100354 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100355   unsigned long jresult ;
100356   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100357   std::size_t result;
100358
100359   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100360   {
100361     try {
100362       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100363     } catch (std::out_of_range& e) {
100364       {
100365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100366       };
100367     } catch (std::exception& e) {
100368       {
100369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100370       };
100371     } catch (Dali::DaliException e) {
100372       {
100373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100374       };
100375     } catch (...) {
100376       {
100377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100378       };
100379     }
100380   }
100381
100382   jresult = (unsigned long)result;
100383   return jresult;
100384 }
100385
100386
100387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100388   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100389   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100390
100391   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100392   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100393   {
100394     try {
100395       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100396     } catch (std::out_of_range& e) {
100397       {
100398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100399       };
100400     } catch (std::exception& e) {
100401       {
100402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100403       };
100404     } catch (Dali::DaliException e) {
100405       {
100406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100407       };
100408     } catch (...) {
100409       {
100410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100411       };
100412     }
100413   }
100414
100415 }
100416
100417
100418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100419   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100420   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100421
100422   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100423   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100424   {
100425     try {
100426       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100427     } catch (std::out_of_range& e) {
100428       {
100429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100430       };
100431     } catch (std::exception& e) {
100432       {
100433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100434       };
100435     } catch (Dali::DaliException e) {
100436       {
100437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100438       };
100439     } catch (...) {
100440       {
100441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100442       };
100443     }
100444   }
100445
100446 }
100447
100448
100449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100450   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100451   Dali::Toolkit::Control arg2 ;
100452   Dali::Toolkit::Control *argp2 ;
100453
100454   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100455   argp2 = (Dali::Toolkit::Control *)jarg2;
100456   if (!argp2) {
100457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100458     return ;
100459   }
100460   arg2 = *argp2;
100461   {
100462     try {
100463       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100464     } catch (std::out_of_range& e) {
100465       {
100466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100467       };
100468     } catch (std::exception& e) {
100469       {
100470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100471       };
100472     } catch (Dali::DaliException e) {
100473       {
100474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100475       };
100476     } catch (...) {
100477       {
100478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100479       };
100480     }
100481   }
100482
100483 }
100484
100485
100486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100487   void * jresult ;
100488   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100489
100490   {
100491     try {
100492       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100493     } catch (std::out_of_range& e) {
100494       {
100495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100496       };
100497     } catch (std::exception& e) {
100498       {
100499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100500       };
100501     } catch (Dali::DaliException e) {
100502       {
100503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100504       };
100505     } catch (...) {
100506       {
100507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100508       };
100509     }
100510   }
100511
100512   jresult = (void *)result;
100513   return jresult;
100514 }
100515
100516
100517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100518   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100519
100520   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100521   {
100522     try {
100523       delete arg1;
100524     } catch (std::out_of_range& e) {
100525       {
100526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100527       };
100528     } catch (std::exception& e) {
100529       {
100530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100531       };
100532     } catch (Dali::DaliException e) {
100533       {
100534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100535       };
100536     } catch (...) {
100537       {
100538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100539       };
100540     }
100541   }
100542
100543 }
100544
100545 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100546   Dali::RefObject *result = NULL;
100547
100548   if (arg1)
100549   {
100550     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100551   }
100552   return result;
100553 }
100554
100555 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100556     return (Dali::RefObject *)jarg1;
100557 }
100558
100559 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100560     return (Dali::SignalObserver *)jarg1;
100561 }
100562
100563 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100564     return (Dali::ConnectionTrackerInterface *)jarg1;
100565 }
100566
100567 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100568     return (Dali::BaseHandle *)jarg1;
100569 }
100570
100571 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100572     return (Dali::BaseHandle *)jarg1;
100573 }
100574
100575 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100576     return (Dali::BaseHandle *)jarg1;
100577 }
100578
100579 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100580     return (Dali::BaseHandle *)jarg1;
100581 }
100582
100583 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100584     return (Dali::BaseHandle *)jarg1;
100585 }
100586
100587 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100588     return (Dali::BaseHandle *)jarg1;
100589 }
100590
100591 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100592     return (Dali::BaseHandle *)jarg1;
100593 }
100594
100595 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100596     return (Dali::BaseHandle *)jarg1;
100597 }
100598
100599 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100600     return (Dali::BaseHandle *)jarg1;
100601 }
100602
100603 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100604     return (Dali::BaseHandle *)jarg1;
100605 }
100606
100607 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100608     return (Dali::BaseHandle *)jarg1;
100609 }
100610
100611 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100612     return (Dali::BaseHandle *)jarg1;
100613 }
100614
100615 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100616     return (Dali::BaseHandle *)jarg1;
100617 }
100618
100619 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100620     return (Dali::Handle *)jarg1;
100621 }
100622
100623 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100624     return (Dali::Handle *)jarg1;
100625 }
100626
100627 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100628     return (Dali::BaseHandle *)jarg1;
100629 }
100630
100631 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100632     return (Dali::BaseHandle *)jarg1;
100633 }
100634
100635 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100636     return (Dali::Handle *)jarg1;
100637 }
100638
100639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100640     return (Dali::BaseHandle *)jarg1;
100641 }
100642
100643 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100644     return (Dali::Handle *)jarg1;
100645 }
100646
100647 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100648     return (Dali::GestureDetector *)jarg1;
100649 }
100650
100651 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100652     return (Dali::Gesture *)jarg1;
100653 }
100654
100655 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100656     return (Dali::Handle *)jarg1;
100657 }
100658
100659 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100660     return (Dali::Actor *)jarg1;
100661 }
100662
100663 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100664     return (Dali::BaseHandle *)jarg1;
100665 }
100666
100667 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100668     return (Dali::RefObject *)jarg1;
100669 }
100670
100671 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100672     return (Dali::Actor *)jarg1;
100673 }
100674
100675 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100676     return (Dali::GestureDetector *)jarg1;
100677 }
100678
100679 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100680     return (Dali::Gesture *)jarg1;
100681 }
100682
100683 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100684     return (Dali::GestureDetector *)jarg1;
100685 }
100686
100687 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100688     return (Dali::Gesture *)jarg1;
100689 }
100690
100691 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100692     return (Dali::GestureDetector *)jarg1;
100693 }
100694
100695 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100696     return (Dali::Gesture *)jarg1;
100697 }
100698
100699 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100700     return (Dali::BaseHandle *)jarg1;
100701 }
100702
100703 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100704     return (Dali::Handle *)jarg1;
100705 }
100706
100707 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100708     return (Dali::Handle *)jarg1;
100709 }
100710
100711 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100712     return (Dali::Handle *)jarg1;
100713 }
100714
100715 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100716     return (Dali::Image *)jarg1;
100717 }
100718
100719 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100720     return (Dali::Image *)jarg1;
100721 }
100722
100723 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100724     return (Dali::Image *)jarg1;
100725 }
100726
100727 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100728     return (Dali::RefObject *)jarg1;
100729 }
100730
100731 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100732     return (Dali::Image *)jarg1;
100733 }
100734
100735 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100736     return (Dali::Image *)jarg1;
100737 }
100738
100739 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100740     return (Dali::ResourceImage *)jarg1;
100741 }
100742
100743 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100744     return (Dali::Actor *)jarg1;
100745 }
100746
100747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100748     return (Dali::BaseHandle *)jarg1;
100749 }
100750
100751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100752     return (Dali::BaseHandle *)jarg1;
100753 }
100754
100755
100756 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100757     return (Dali::BaseHandle *)jarg1;
100758 }
100759
100760 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100761     return (Dali::BaseHandle *)jarg1;
100762 }
100763
100764 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100765     return (Dali::CustomActorImpl *)jarg1;
100766 }
100767
100768 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100769     return (Dali::CustomActor *)jarg1;
100770 }
100771
100772 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100773     return (Dali::BaseHandle *)jarg1;
100774 }
100775
100776 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100777     return (Dali::Toolkit::Control *)jarg1;
100778 }
100779
100780 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100781     return (Dali::Toolkit::Control *)jarg1;
100782 }
100783
100784 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100785     return (Dali::Toolkit::Button *)jarg1;
100786 }
100787
100788 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100789     return (Dali::Toolkit::Button *)jarg1;
100790 }
100791
100792 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100793     return (Dali::Toolkit::Button *)jarg1;
100794 }
100795
100796 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100797     return (Dali::Toolkit::Control *)jarg1;
100798 }
100799
100800 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100801     return (Dali::Toolkit::Control *)jarg1;
100802 }
100803
100804 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100805     return (Dali::Toolkit::Control *)jarg1;
100806 }
100807
100808 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100809     return (Dali::Toolkit::Control *)jarg1;
100810 }
100811
100812 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100813     return (Dali::Toolkit::Control *)jarg1;
100814 }
100815
100816 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100817     return (Dali::RefObject *)jarg1;
100818 }
100819
100820 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100821     return (Dali::Toolkit::Scrollable *)jarg1;
100822 }
100823
100824 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100825     return (Dali::BaseHandle *)jarg1;
100826 }
100827
100828 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100829     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100830 }
100831
100832 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100833     return (Dali::RefObject *)jarg1;
100834 }
100835
100836 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100837     return (Dali::Toolkit::Ruler *)jarg1;
100838 }
100839
100840 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100841     return (Dali::Toolkit::Ruler *)jarg1;
100842 }
100843
100844 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100845     return (Dali::Toolkit::Scrollable *)jarg1;
100846 }
100847
100848 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100849     return (Dali::Toolkit::Control *)jarg1;
100850 }
100851
100852
100853 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100854     return (Dali::Toolkit::Control *)jarg1;
100855 }
100856
100857 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100858     return (Dali::BaseHandle *)jarg1;
100859 }
100860
100861 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100862     return (Dali::BaseHandle *)jarg1;
100863 }
100864
100865 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100866     return (Dali::Toolkit::Control *)jarg1;
100867 }
100868
100869 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100870     return (Dali::Toolkit::Control *)jarg1;
100871 }
100872
100873 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100874     return (Dali::Toolkit::Control *)jarg1;
100875 }
100876
100877 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100878     return (Dali::Toolkit::Control *)jarg1;
100879 }
100880
100881 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100882     return (Dali::Toolkit::Control *)jarg1;
100883 }
100884
100885 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100886     return (Dali::Toolkit::Control *)jarg1;
100887 }
100888
100889 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100890     return (Dali::Toolkit::PageTurnView *)jarg1;
100891 }
100892
100893 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100894     return (Dali::Toolkit::PageTurnView *)jarg1;
100895 }
100896
100897 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100898     return (Dali::Toolkit::Button *)jarg1;
100899 }
100900
100901 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100902     return (Dali::BaseHandle *)jarg1;
100903 }
100904
100905 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100906     return (Dali::BaseHandle *)jarg1;
100907 }
100908
100909 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100910     return (Dali::BaseHandle *)jarg1;
100911 }
100912
100913 /*
100914  * Widget binding
100915  */
100916 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100917     return (Dali::BaseHandle *)jarg1;
100918 }
100919
100920 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100921     return (Dali::BaseObject *)jarg1;
100922 }
100923
100924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100925   void * jresult ;
100926   Dali::Widget result;
100927
100928   {
100929     try {
100930       result = Dali::Widget::New();
100931     } catch (std::out_of_range& e) {
100932       {
100933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100934       };
100935     } catch (std::exception& e) {
100936       {
100937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100938       };
100939     } catch (...) {
100940       {
100941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100942       };
100943     }
100944   }
100945   jresult = new Dali::Widget((const Dali::Widget &)result);
100946   return jresult;
100947 }
100948
100949
100950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100951   void * jresult ;
100952   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100953   Dali::Widget result;
100954
100955   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100956
100957   if (!arg1) {
100958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100959     return 0;
100960   }
100961   {
100962     try {
100963       jresult = new Dali::Widget(arg1);
100964     } catch (std::out_of_range& e) {
100965       {
100966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100967       };
100968     } catch (std::exception& e) {
100969       {
100970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100971       };
100972     } catch (...) {
100973       {
100974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100975       };
100976     }
100977   }
100978   return jresult;
100979 }
100980
100981
100982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100983   void * jresult ;
100984   Dali::Widget *result = 0 ;
100985
100986   {
100987     try {
100988       result = (Dali::Widget *)new Dali::Widget();
100989     } catch (std::out_of_range& e) {
100990       {
100991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100992       };
100993     } catch (std::exception& e) {
100994       {
100995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100996       };
100997     } catch (...) {
100998       {
100999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101000       };
101001     }
101002   }
101003   jresult = (void *)result;
101004   return jresult;
101005 }
101006
101007
101008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101009   void * jresult ;
101010   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101011   Dali::Widget *arg2 = 0 ;
101012   Dali::Widget *result = 0 ;
101013
101014   arg1 = (Dali::Widget *)jarg1;
101015   arg2 = (Dali::Widget *)jarg2;
101016   if (!arg2) {
101017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101018     return 0;
101019   }
101020   {
101021     try {
101022       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101023     } catch (std::out_of_range& e) {
101024       {
101025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101026       };
101027     } catch (std::exception& e) {
101028       {
101029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101030       };
101031     } catch (...) {
101032       {
101033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101034       };
101035     }
101036   }
101037   jresult = (void *)result;
101038   return jresult;
101039 }
101040
101041
101042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101043   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101044
101045   arg1 = (Dali::Widget *)jarg1;
101046   {
101047     try {
101048       delete arg1;
101049     } catch (std::out_of_range& e) {
101050       {
101051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101052       };
101053     } catch (std::exception& e) {
101054       {
101055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101056       };
101057     } catch (...) {
101058       {
101059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101060       };
101061     }
101062   }
101063 }
101064
101065
101066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101067   void * jresult ;
101068   SwigDirector_WidgetImpl* result;
101069   {
101070     try {
101071       result = new SwigDirector_WidgetImpl();
101072     } catch (std::out_of_range& e) {
101073       {
101074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101075       };
101076     } catch (std::exception& e) {
101077       {
101078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101079       };
101080     } catch (...) {
101081       {
101082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101083       };
101084     }
101085   }
101086   jresult = result;
101087   return jresult;
101088 }
101089
101090
101091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101092   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101093   std::string *arg2 = 0 ;
101094   Dali::Window arg3 ;
101095   Dali::Window *argp3 ;
101096
101097   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101098   if (!jarg2) {
101099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101100     return ;
101101   }
101102   std::string arg2_str(jarg2);
101103   arg2 = &arg2_str;
101104   argp3 = (Dali::Window *)jarg3;
101105   if (!argp3) {
101106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101107     return ;
101108   }
101109   arg3 = *argp3;
101110   {
101111     try {
101112       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101113     } catch (std::out_of_range& e) {
101114       {
101115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101116       };
101117     } catch (std::exception& e) {
101118       {
101119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101120       };
101121     } catch (...) {
101122       {
101123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101124       };
101125     }
101126   }
101127 }
101128
101129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101130   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101131   std::string *arg2 = 0 ;
101132   Dali::Window arg3 ;
101133   Dali::Window *argp3 ;
101134
101135   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101136   if (!jarg2) {
101137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101138     return ;
101139   }
101140   std::string arg2_str(jarg2);
101141   arg2 = &arg2_str;
101142   argp3 = (Dali::Window *)jarg3;
101143   if (!argp3) {
101144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101145     return ;
101146   }
101147   arg3 = *argp3;
101148   {
101149     try {
101150       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101151     } catch (std::out_of_range& e) {
101152       {
101153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101154       };
101155     } catch (std::exception& e) {
101156       {
101157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101158       };
101159     } catch (...) {
101160       {
101161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101162       };
101163     }
101164   }
101165 }
101166
101167
101168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101169   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101170   std::string *arg2 = 0 ;
101171   Dali::Widget::Termination arg3 ;
101172
101173   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101174   if (!jarg2) {
101175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101176     return ;
101177   }
101178   std::string arg2_str(jarg2);
101179   arg2 = &arg2_str;
101180   arg3 = (Dali::Widget::Termination)jarg3;
101181   {
101182     try {
101183       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101184     } catch (std::out_of_range& e) {
101185       {
101186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101187       };
101188     } catch (std::exception& e) {
101189       {
101190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101191       };
101192     } catch (...) {
101193       {
101194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101195       };
101196     }
101197   }
101198 }
101199
101200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101201   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101202   std::string *arg2 = 0 ;
101203   Dali::Widget::Termination arg3 ;
101204
101205   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101206   if (!jarg2) {
101207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101208     return ;
101209   }
101210   std::string arg2_str(jarg2);
101211   arg2 = &arg2_str;
101212   arg3 = (Dali::Widget::Termination)jarg3;
101213   {
101214     try {
101215       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101216     } catch (std::out_of_range& e) {
101217       {
101218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101219       };
101220     } catch (std::exception& e) {
101221       {
101222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101223       };
101224     } catch (...) {
101225       {
101226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101227       };
101228     }
101229   }
101230 }
101231
101232
101233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101234   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101235
101236   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101237   {
101238     try {
101239       (arg1)->OnPause();
101240     } catch (std::out_of_range& e) {
101241       {
101242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101243       };
101244     } catch (std::exception& e) {
101245       {
101246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101247       };
101248     } catch (...) {
101249       {
101250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101251       };
101252     }
101253   }
101254 }
101255
101256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101257   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101258
101259   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101260   {
101261     try {
101262       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101263     } catch (std::out_of_range& e) {
101264       {
101265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101266       };
101267     } catch (std::exception& e) {
101268       {
101269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101270       };
101271     } catch (...) {
101272       {
101273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101274       };
101275     }
101276   }
101277 }
101278
101279
101280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101281   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101282
101283   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101284   {
101285     try {
101286       (arg1)->OnResume();
101287     } catch (std::out_of_range& e) {
101288       {
101289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101290       };
101291     } catch (std::exception& e) {
101292       {
101293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101294       };
101295     } catch (...) {
101296       {
101297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101298       };
101299     }
101300   }
101301 }
101302
101303
101304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101305   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101306
101307   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101308   {
101309     try {
101310       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101311     } catch (std::out_of_range& e) {
101312       {
101313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101314       };
101315     } catch (std::exception& e) {
101316       {
101317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101318       };
101319     } catch (...) {
101320       {
101321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101322       };
101323     }
101324   }
101325 }
101326
101327
101328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101329   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101330   Dali::Window arg2 ;
101331   Dali::Window *argp2 ;
101332
101333   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101334   argp2 = (Dali::Window *)jarg2;
101335   if (!argp2) {
101336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101337     return ;
101338   }
101339   arg2 = *argp2;
101340   {
101341     try {
101342       (arg1)->OnResize(arg2);
101343     } catch (std::out_of_range& e) {
101344       {
101345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101346       };
101347     } catch (std::exception& e) {
101348       {
101349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101350       };
101351     } catch (...) {
101352       {
101353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101354       };
101355     }
101356   }
101357 }
101358
101359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101360   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101361   Dali::Window arg2 ;
101362   Dali::Window *argp2 ;
101363
101364   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101365   argp2 = (Dali::Window *)jarg2;
101366   if (!argp2) {
101367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101368     return ;
101369   }
101370   arg2 = *argp2;
101371   {
101372     try {
101373       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101374     } catch (std::out_of_range& e) {
101375       {
101376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101377       };
101378     } catch (std::exception& e) {
101379       {
101380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101381       };
101382     } catch (...) {
101383       {
101384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101385       };
101386     }
101387   }
101388 }
101389
101390
101391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101392   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101393   std::string *arg2 = 0 ;
101394   int arg3 ;
101395
101396   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101397   if (!jarg2) {
101398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101399     return ;
101400   }
101401   std::string arg2_str(jarg2);
101402   arg2 = &arg2_str;
101403   arg3 = (int)jarg3;
101404   {
101405     try {
101406       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101407     } catch (std::out_of_range& e) {
101408       {
101409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101410       };
101411     } catch (std::exception& e) {
101412       {
101413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101414       };
101415     } catch (...) {
101416       {
101417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101418       };
101419     }
101420   }
101421 }
101422
101423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101424   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101425   std::string *arg2 = 0 ;
101426   int arg3 ;
101427
101428   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101429   if (!jarg2) {
101430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101431     return ;
101432   }
101433   std::string arg2_str(jarg2);
101434   arg2 = &arg2_str;
101435   arg3 = (int)jarg3;
101436   {
101437     try {
101438       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101439     } catch (std::out_of_range& e) {
101440       {
101441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101442       };
101443     } catch (std::exception& e) {
101444       {
101445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101446       };
101447     } catch (...) {
101448       {
101449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101450       };
101451     }
101452   }
101453 }
101454
101455
101456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101457   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101458   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101459   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101460
101461   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101462   arg2 = (Dali::SlotObserver *)jarg2;
101463   arg3 = (Dali::CallbackBase *)jarg3;
101464   {
101465     try {
101466       (arg1)->SignalConnected(arg2,arg3);
101467     } catch (std::out_of_range& e) {
101468       {
101469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101470       };
101471     } catch (std::exception& e) {
101472       {
101473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101474       };
101475     } catch (...) {
101476       {
101477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101478       };
101479     }
101480   }
101481 }
101482
101483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101484   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101485   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101486   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101487
101488   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101489   arg2 = (Dali::SlotObserver *)jarg2;
101490   arg3 = (Dali::CallbackBase *)jarg3;
101491   {
101492     try {
101493       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101494     } catch (std::out_of_range& e) {
101495       {
101496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101497       };
101498     } catch (std::exception& e) {
101499       {
101500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101501       };
101502     } catch (...) {
101503       {
101504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101505       };
101506     }
101507   }
101508 }
101509
101510
101511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101512   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101513   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101514   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101515
101516   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101517   arg2 = (Dali::SlotObserver *)jarg2;
101518   arg3 = (Dali::CallbackBase *)jarg3;
101519   {
101520     try {
101521       (arg1)->SignalDisconnected(arg2,arg3);
101522     } catch (std::out_of_range& e) {
101523       {
101524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101525       };
101526     } catch (std::exception& e) {
101527       {
101528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101529       };
101530     } catch (...) {
101531       {
101532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101533       };
101534     }
101535   }
101536 }
101537
101538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101539   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101540   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101541   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101542
101543   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101544   arg2 = (Dali::SlotObserver *)jarg2;
101545   arg3 = (Dali::CallbackBase *)jarg3;
101546   {
101547     try {
101548       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101549     } catch (std::out_of_range& e) {
101550       {
101551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101552       };
101553     } catch (std::exception& e) {
101554       {
101555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101556       };
101557     } catch (...) {
101558       {
101559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101560       };
101561     }
101562   }
101563 }
101564
101565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101566   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101567   std::string *arg2 = 0 ;
101568
101569   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101570   if (!jarg2) {
101571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101572     return ;
101573   }
101574   std::string arg2_str(jarg2);
101575   arg2 = &arg2_str;
101576   {
101577     try {
101578       (arg1)->SetContentInfo((std::string const &)*arg2);
101579     } catch (std::out_of_range& e) {
101580       {
101581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101582       };
101583     } catch (std::exception& e) {
101584       {
101585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101586       };
101587     } catch (...) {
101588       {
101589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101590       };
101591     }
101592   }
101593 }
101594
101595
101596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101597   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101598   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101599
101600   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101601   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101602   {
101603     try {
101604       (arg1)->SetImpl(arg2);
101605     } catch (std::out_of_range& e) {
101606       {
101607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101608       };
101609     } catch (std::exception& e) {
101610       {
101611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101612       };
101613     } catch (...) {
101614       {
101615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101616       };
101617     }
101618   }
101619 }
101620
101621 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) {
101622
101623   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101624   if (director) {
101625     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101626   }
101627 }
101628
101629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101630   void * jresult ;
101631   Dali::Widget *arg1 = 0 ;
101632   SwigDirector_WidgetImpl *result = 0 ;
101633
101634   arg1 = (Dali::Widget *)jarg1;
101635   if (!arg1) {
101636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101637     return 0;
101638   }
101639   {
101640     try {
101641       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101642     } catch (std::out_of_range& e) {
101643       {
101644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101645       };
101646     } catch (std::exception& e) {
101647       {
101648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101649       };
101650     } catch (...) {
101651       {
101652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101653       };
101654     }
101655   }
101656
101657   jresult = (void *)result;
101658   return jresult;
101659 }
101660
101661
101662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101663   void * jresult ;
101664   int *arg1 = (int *) 0 ;
101665   char ***arg2 ;
101666   std::string *arg3 = 0 ;
101667   Dali::WidgetApplication result;
101668   {
101669     int index = 0;
101670     int length = 0;
101671     char *retPtr;
101672     char *nextPtr;
101673     argWidgetC = jarg1;
101674     argWidgetV = new char*[jarg1 + 1];
101675
101676     retPtr = strtok_r( jarg2, " ", &nextPtr);
101677     if( retPtr )
101678     {
101679       length = strlen(retPtr);
101680     }
101681     argWidgetV[index] = new char[length + 1];
101682     if( retPtr )
101683     {
101684       strncpy(argWidgetV[index], retPtr, length);
101685     }
101686     argWidgetV[index][length] = '\0';
101687     index++;
101688
101689     while (index < jarg1)
101690     {
101691       length = 0;
101692       retPtr = strtok_r(NULL, " ", &nextPtr);
101693       if( retPtr )
101694       {
101695         length = strlen(retPtr);
101696       }
101697       argWidgetV[index] = new char[length + 1];
101698       if( retPtr )
101699       {
101700         strncpy(argWidgetV[index], retPtr, length);
101701       }
101702       argWidgetV[index][length] = '\0';
101703       index++;
101704     }
101705
101706     argWidgetV[jarg1] = NULL;
101707     argWidgetC = jarg1;
101708
101709     arg1 = &argWidgetC;
101710     arg2 = &argWidgetV;
101711   }
101712
101713   if (!jarg3) {
101714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101715     return 0;
101716   }
101717   std::string arg3_str(jarg3);
101718   arg3 = &arg3_str;
101719   {
101720     try {
101721       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101722     } catch (std::out_of_range& e) {
101723       {
101724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101725       };
101726     } catch (std::exception& e) {
101727       {
101728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101729       };
101730     } catch (...) {
101731       {
101732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101733       };
101734     }
101735   }
101736   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101737
101738   return jresult;
101739 }
101740
101741
101742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101743   void * jresult ;
101744   Dali::WidgetApplication *result = 0 ;
101745
101746   {
101747     try {
101748       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101749     } catch (std::out_of_range& e) {
101750       {
101751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101752       };
101753     } catch (std::exception& e) {
101754       {
101755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101756       };
101757     } catch (...) {
101758       {
101759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101760       };
101761     }
101762   }
101763   jresult = (void *)result;
101764   return jresult;
101765 }
101766
101767
101768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101769   void * jresult ;
101770   Dali::WidgetApplication *arg1 = 0 ;
101771   Dali::WidgetApplication *result = 0 ;
101772
101773   arg1 = (Dali::WidgetApplication *)jarg1;
101774   if (!arg1) {
101775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101776     return 0;
101777   }
101778   {
101779     try {
101780       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101781     } catch (std::out_of_range& e) {
101782       {
101783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101784       };
101785     } catch (std::exception& e) {
101786       {
101787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101788       };
101789     } catch (...) {
101790       {
101791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101792       };
101793     }
101794   }
101795   jresult = (void *)result;
101796   return jresult;
101797 }
101798
101799
101800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101801   void * jresult ;
101802   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101803   Dali::WidgetApplication *arg2 = 0 ;
101804   Dali::WidgetApplication *result = 0 ;
101805
101806   arg1 = (Dali::WidgetApplication *)jarg1;
101807   arg2 = (Dali::WidgetApplication *)jarg2;
101808   if (!arg2) {
101809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101810     return 0;
101811   }
101812   {
101813     try {
101814       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101815     } catch (std::out_of_range& e) {
101816       {
101817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101818       };
101819     } catch (std::exception& e) {
101820       {
101821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101822       };
101823     } catch (...) {
101824       {
101825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101826       };
101827     }
101828   }
101829   jresult = (void *)result;
101830   return jresult;
101831 }
101832
101833
101834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101835   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101836
101837   arg1 = (Dali::WidgetApplication *)jarg1;
101838   {
101839     try {
101840       delete arg1;
101841       if( argWidgetV )
101842       {
101843         // free string data
101844         for( int i=0; i < argWidgetC+1; i++)
101845         {
101846           delete [] argWidgetV[i];
101847         }
101848         delete [] argWidgetV;
101849       }
101850     } catch (std::out_of_range& e) {
101851       {
101852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101853       };
101854     } catch (std::exception& e) {
101855       {
101856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101857       };
101858     } catch (...) {
101859       {
101860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101861       };
101862     }
101863   }
101864 }
101865
101866
101867 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101868 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101869
101870 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101871 {
101872   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101873   return *widget;
101874 }
101875
101876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101877   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101878   std::string *arg2 = 0 ;
101879
101880   arg1 = (Dali::WidgetApplication *)jarg1;
101881   if (!jarg2) {
101882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101883     return ;
101884   }
101885   std::string arg2_str(*jarg2);
101886   arg2 = &arg2_str;
101887
101888   if(!_CSharpCreateWidgetFunction)
101889   {
101890     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101891   }
101892
101893   {
101894     try {
101895       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101896     } catch (std::out_of_range& e) {
101897       {
101898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101899       };
101900     } catch (std::exception& e) {
101901       {
101902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101903       };
101904     } catch (...) {
101905       {
101906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101907       };
101908     }
101909   }
101910
101911   //Typemap argout in c++ file.
101912   //This will convert c++ string to c# string
101913   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101914 }
101915
101916
101917 //for PixelBuffer and ImageLoading
101918
101919 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101920     return (Dali::BaseHandle *)jarg1;
101921 }
101922
101923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101924   void * jresult ;
101925   unsigned int arg1 ;
101926   unsigned int arg2 ;
101927   Dali::Pixel::Format arg3 ;
101928   Dali::Devel::PixelBuffer result;
101929
101930   arg1 = (unsigned int)jarg1;
101931   arg2 = (unsigned int)jarg2;
101932   arg3 = (Dali::Pixel::Format)jarg3;
101933   {
101934     try {
101935       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101936     } catch (std::out_of_range& e) {
101937       {
101938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101939       };
101940     } catch (std::exception& e) {
101941       {
101942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101943       };
101944     } catch (...) {
101945       {
101946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101947       };
101948     }
101949   }
101950   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101951   return jresult;
101952 }
101953
101954
101955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101956   void * jresult ;
101957   Dali::Devel::PixelBuffer *result = 0 ;
101958
101959   {
101960     try {
101961       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101962     } catch (std::out_of_range& e) {
101963       {
101964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101965       };
101966     } catch (std::exception& e) {
101967       {
101968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101969       };
101970     } catch (...) {
101971       {
101972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101973       };
101974     }
101975   }
101976   jresult = (void *)result;
101977   return jresult;
101978 }
101979
101980
101981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101982   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101983
101984   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101985   {
101986     try {
101987       delete arg1;
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_new_PixelBuffer__SWIG_1(void * jarg1) {
102006   void * jresult ;
102007   Dali::Devel::PixelBuffer *arg1 = 0 ;
102008   Dali::Devel::PixelBuffer *result = 0 ;
102009
102010   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102011   if (!arg1) {
102012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102013     return 0;
102014   }
102015   {
102016     try {
102017       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102018     } catch (std::out_of_range& e) {
102019       {
102020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102021       };
102022     } catch (std::exception& e) {
102023       {
102024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102025       };
102026     } catch (...) {
102027       {
102028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102029       };
102030     }
102031   }
102032   jresult = (void *)result;
102033   return jresult;
102034 }
102035
102036
102037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102038   void * jresult ;
102039   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102040   Dali::Devel::PixelBuffer *arg2 = 0 ;
102041   Dali::Devel::PixelBuffer *result = 0 ;
102042
102043   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102044   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102045   if (!arg2) {
102046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102047     return 0;
102048   }
102049   {
102050     try {
102051       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102052     } catch (std::out_of_range& e) {
102053       {
102054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102055       };
102056     } catch (std::exception& e) {
102057       {
102058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102059       };
102060     } catch (...) {
102061       {
102062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102063       };
102064     }
102065   }
102066   jresult = (void *)result;
102067   return jresult;
102068 }
102069
102070
102071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102072   void * jresult ;
102073   Dali::Devel::PixelBuffer *arg1 = 0 ;
102074   Dali::PixelData result;
102075
102076   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102077   if (!arg1) {
102078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102079     return 0;
102080   }
102081   {
102082     try {
102083       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102084     } catch (std::out_of_range& e) {
102085       {
102086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102087       };
102088     } catch (std::exception& e) {
102089       {
102090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102091       };
102092     } catch (...) {
102093       {
102094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102095       };
102096     }
102097   }
102098   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102099   return jresult;
102100 }
102101
102102
102103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102104   void * jresult ;
102105   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102106   Dali::PixelData result;
102107
102108   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102109   {
102110     try {
102111       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102112     } catch (std::out_of_range& e) {
102113       {
102114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102115       };
102116     } catch (std::exception& e) {
102117       {
102118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102119       };
102120     } catch (...) {
102121       {
102122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102123       };
102124     }
102125   }
102126   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102127   return jresult;
102128 }
102129
102130
102131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102132   void * jresult ;
102133   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102134   unsigned char *result = 0 ;
102135
102136   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102137   {
102138     try {
102139       result = (unsigned char *)(arg1)->GetBuffer();
102140     } catch (std::out_of_range& e) {
102141       {
102142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102143       };
102144     } catch (std::exception& e) {
102145       {
102146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102147       };
102148     } catch (...) {
102149       {
102150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102151       };
102152     }
102153   }
102154   jresult = (void *)result;
102155   return jresult;
102156 }
102157
102158
102159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102160   unsigned int jresult ;
102161   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102162   unsigned int result;
102163
102164   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102165   {
102166     try {
102167       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102168     } catch (std::out_of_range& e) {
102169       {
102170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102171       };
102172     } catch (std::exception& e) {
102173       {
102174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102175       };
102176     } catch (...) {
102177       {
102178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102179       };
102180     }
102181   }
102182   jresult = result;
102183   return jresult;
102184 }
102185
102186
102187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102188   unsigned int jresult ;
102189   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102190   unsigned int result;
102191
102192   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102193   {
102194     try {
102195       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102196     } catch (std::out_of_range& e) {
102197       {
102198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102199       };
102200     } catch (std::exception& e) {
102201       {
102202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102203       };
102204     } catch (...) {
102205       {
102206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102207       };
102208     }
102209   }
102210   jresult = result;
102211   return jresult;
102212 }
102213
102214
102215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102216   int jresult ;
102217   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102218   Dali::Pixel::Format result;
102219
102220   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102221   {
102222     try {
102223       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102224     } catch (std::out_of_range& e) {
102225       {
102226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102227       };
102228     } catch (std::exception& e) {
102229       {
102230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102231       };
102232     } catch (...) {
102233       {
102234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102235       };
102236     }
102237   }
102238   jresult = (int)result;
102239   return jresult;
102240 }
102241
102242
102243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102244   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102245   Dali::Devel::PixelBuffer arg2 ;
102246   float arg3 ;
102247   bool arg4 ;
102248   Dali::Devel::PixelBuffer *argp2 ;
102249
102250   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102251   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102252   if (!argp2) {
102253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102254     return ;
102255   }
102256   arg2 = *argp2;
102257   arg3 = (float)jarg3;
102258   arg4 = jarg4 ? true : false;
102259   {
102260     try {
102261       (arg1)->ApplyMask(arg2,arg3,arg4);
102262     } catch (std::out_of_range& e) {
102263       {
102264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102265       };
102266     } catch (std::exception& e) {
102267       {
102268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102269       };
102270     } catch (...) {
102271       {
102272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102273       };
102274     }
102275   }
102276 }
102277
102278
102279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102280   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102281   Dali::Devel::PixelBuffer arg2 ;
102282   float arg3 ;
102283   Dali::Devel::PixelBuffer *argp2 ;
102284
102285   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102286   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102287   if (!argp2) {
102288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102289     return ;
102290   }
102291   arg2 = *argp2;
102292   arg3 = (float)jarg3;
102293   {
102294     try {
102295       (arg1)->ApplyMask(arg2,arg3);
102296     } catch (std::out_of_range& e) {
102297       {
102298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102299       };
102300     } catch (std::exception& e) {
102301       {
102302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102303       };
102304     } catch (...) {
102305       {
102306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102307       };
102308     }
102309   }
102310 }
102311
102312
102313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102314   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102315   Dali::Devel::PixelBuffer arg2 ;
102316   Dali::Devel::PixelBuffer *argp2 ;
102317
102318   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102319   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102320   if (!argp2) {
102321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102322     return ;
102323   }
102324   arg2 = *argp2;
102325   {
102326     try {
102327       (arg1)->ApplyMask(arg2);
102328     } catch (std::out_of_range& e) {
102329       {
102330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102331       };
102332     } catch (std::exception& e) {
102333       {
102334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102335       };
102336     } catch (...) {
102337       {
102338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102339       };
102340     }
102341   }
102342 }
102343
102344
102345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102346   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102347   float arg2 ;
102348
102349   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102350   arg2 = (float)jarg2;
102351   {
102352     try {
102353       (arg1)->ApplyGaussianBlur(arg2);
102354     } catch (std::out_of_range& e) {
102355       {
102356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102357       };
102358     } catch (std::exception& e) {
102359       {
102360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102361       };
102362     } catch (...) {
102363       {
102364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102365       };
102366     }
102367   }
102368 }
102369
102370
102371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102372   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102373   uint16_t arg2 ;
102374   uint16_t arg3 ;
102375   uint16_t arg4 ;
102376   uint16_t arg5 ;
102377
102378   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102379   arg2 = (uint16_t)jarg2;
102380   arg3 = (uint16_t)jarg3;
102381   arg4 = (uint16_t)jarg4;
102382   arg5 = (uint16_t)jarg5;
102383   {
102384     try {
102385       (arg1)->Crop(arg2,arg3,arg4,arg5);
102386     } catch (std::out_of_range& e) {
102387       {
102388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102389       };
102390     } catch (std::exception& e) {
102391       {
102392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102393       };
102394     } catch (...) {
102395       {
102396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102397       };
102398     }
102399   }
102400 }
102401
102402
102403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102404   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102405   uint16_t arg2 ;
102406   uint16_t arg3 ;
102407
102408   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102409   arg2 = (uint16_t)jarg2;
102410   arg3 = (uint16_t)jarg3;
102411   {
102412     try {
102413       (arg1)->Resize(arg2,arg3);
102414     } catch (std::out_of_range& e) {
102415       {
102416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102417       };
102418     } catch (std::exception& e) {
102419       {
102420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102421       };
102422     } catch (...) {
102423       {
102424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102425       };
102426     }
102427   }
102428 }
102429
102430
102431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102432   void * jresult ;
102433   std::string *arg1 = 0 ;
102434   Dali::ImageDimensions arg2 ;
102435   Dali::FittingMode::Type arg3 ;
102436   Dali::SamplingMode::Type arg4 ;
102437   bool arg5 ;
102438   Dali::ImageDimensions *argp2 ;
102439   Dali::Devel::PixelBuffer result;
102440
102441   if (!jarg1) {
102442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102443     return 0;
102444   }
102445   std::string arg1_str(jarg1);
102446   arg1 = &arg1_str;
102447   argp2 = (Dali::ImageDimensions *)jarg2;
102448   if (!argp2) {
102449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102450     return 0;
102451   }
102452   arg2 = *argp2;
102453   arg3 = (Dali::FittingMode::Type)jarg3;
102454   arg4 = (Dali::SamplingMode::Type)jarg4;
102455   arg5 = jarg5 ? true : false;
102456   {
102457     try {
102458       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102459     } catch (std::out_of_range& e) {
102460       {
102461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102462       };
102463     } catch (std::exception& e) {
102464       {
102465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102466       };
102467     } catch (...) {
102468       {
102469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102470       };
102471     }
102472   }
102473   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102474
102475   return jresult;
102476 }
102477
102478
102479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102480   void * jresult ;
102481   std::string *arg1 = 0 ;
102482   Dali::ImageDimensions arg2 ;
102483   Dali::FittingMode::Type arg3 ;
102484   Dali::SamplingMode::Type arg4 ;
102485   Dali::ImageDimensions *argp2 ;
102486   Dali::Devel::PixelBuffer result;
102487
102488   if (!jarg1) {
102489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102490     return 0;
102491   }
102492   std::string arg1_str(jarg1);
102493   arg1 = &arg1_str;
102494   argp2 = (Dali::ImageDimensions *)jarg2;
102495   if (!argp2) {
102496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102497     return 0;
102498   }
102499   arg2 = *argp2;
102500   arg3 = (Dali::FittingMode::Type)jarg3;
102501   arg4 = (Dali::SamplingMode::Type)jarg4;
102502   {
102503     try {
102504       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102505     } catch (std::out_of_range& e) {
102506       {
102507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102508       };
102509     } catch (std::exception& e) {
102510       {
102511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102512       };
102513     } catch (...) {
102514       {
102515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102516       };
102517     }
102518   }
102519   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102520
102521   return jresult;
102522 }
102523
102524
102525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102526   void * jresult ;
102527   std::string *arg1 = 0 ;
102528   Dali::ImageDimensions arg2 ;
102529   Dali::FittingMode::Type arg3 ;
102530   Dali::ImageDimensions *argp2 ;
102531   Dali::Devel::PixelBuffer result;
102532
102533   if (!jarg1) {
102534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102535     return 0;
102536   }
102537   std::string arg1_str(jarg1);
102538   arg1 = &arg1_str;
102539   argp2 = (Dali::ImageDimensions *)jarg2;
102540   if (!argp2) {
102541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102542     return 0;
102543   }
102544   arg2 = *argp2;
102545   arg3 = (Dali::FittingMode::Type)jarg3;
102546   {
102547     try {
102548       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102549     } catch (std::out_of_range& e) {
102550       {
102551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102552       };
102553     } catch (std::exception& e) {
102554       {
102555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102556       };
102557     } catch (...) {
102558       {
102559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102560       };
102561     }
102562   }
102563   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102564
102565   return jresult;
102566 }
102567
102568
102569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102570   void * jresult ;
102571   std::string *arg1 = 0 ;
102572   Dali::ImageDimensions arg2 ;
102573   Dali::ImageDimensions *argp2 ;
102574   Dali::Devel::PixelBuffer result;
102575
102576   if (!jarg1) {
102577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102578     return 0;
102579   }
102580   std::string arg1_str(jarg1);
102581   arg1 = &arg1_str;
102582   argp2 = (Dali::ImageDimensions *)jarg2;
102583   if (!argp2) {
102584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102585     return 0;
102586   }
102587   arg2 = *argp2;
102588   {
102589     try {
102590       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102591     } catch (std::out_of_range& e) {
102592       {
102593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102594       };
102595     } catch (std::exception& e) {
102596       {
102597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102598       };
102599     } catch (...) {
102600       {
102601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102602       };
102603     }
102604   }
102605   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102606
102607   return jresult;
102608 }
102609
102610
102611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102612   void * jresult ;
102613   std::string *arg1 = 0 ;
102614   Dali::Devel::PixelBuffer result;
102615
102616   if (!jarg1) {
102617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102618     return 0;
102619   }
102620   std::string arg1_str(jarg1);
102621   arg1 = &arg1_str;
102622   {
102623     try {
102624       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102625     } catch (std::out_of_range& e) {
102626       {
102627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102628       };
102629     } catch (std::exception& e) {
102630       {
102631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102632       };
102633     } catch (...) {
102634       {
102635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102636       };
102637     }
102638   }
102639   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102640
102641   return jresult;
102642 }
102643
102644
102645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102646   void * jresult ;
102647   std::string *arg1 = 0 ;
102648   Dali::ImageDimensions arg2 ;
102649   Dali::FittingMode::Type arg3 ;
102650   Dali::SamplingMode::Type arg4 ;
102651   bool arg5 ;
102652   Dali::ImageDimensions *argp2 ;
102653   Dali::ImageDimensions result;
102654
102655   if (!jarg1) {
102656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102657     return 0;
102658   }
102659   std::string arg1_str(jarg1);
102660   arg1 = &arg1_str;
102661   argp2 = (Dali::ImageDimensions *)jarg2;
102662   if (!argp2) {
102663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102664     return 0;
102665   }
102666   arg2 = *argp2;
102667   arg3 = (Dali::FittingMode::Type)jarg3;
102668   arg4 = (Dali::SamplingMode::Type)jarg4;
102669   arg5 = jarg5 ? true : false;
102670   {
102671     try {
102672       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102673     } catch (std::out_of_range& e) {
102674       {
102675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102676       };
102677     } catch (std::exception& e) {
102678       {
102679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102680       };
102681     } catch (...) {
102682       {
102683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102684       };
102685     }
102686   }
102687   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102688
102689   return jresult;
102690 }
102691
102692
102693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102694   void * jresult ;
102695   std::string *arg1 = 0 ;
102696   Dali::ImageDimensions arg2 ;
102697   Dali::FittingMode::Type arg3 ;
102698   Dali::SamplingMode::Type arg4 ;
102699   Dali::ImageDimensions *argp2 ;
102700   Dali::ImageDimensions result;
102701
102702   if (!jarg1) {
102703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102704     return 0;
102705   }
102706   std::string arg1_str(jarg1);
102707   arg1 = &arg1_str;
102708   argp2 = (Dali::ImageDimensions *)jarg2;
102709   if (!argp2) {
102710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102711     return 0;
102712   }
102713   arg2 = *argp2;
102714   arg3 = (Dali::FittingMode::Type)jarg3;
102715   arg4 = (Dali::SamplingMode::Type)jarg4;
102716   {
102717     try {
102718       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102719     } catch (std::out_of_range& e) {
102720       {
102721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102722       };
102723     } catch (std::exception& e) {
102724       {
102725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102726       };
102727     } catch (...) {
102728       {
102729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102730       };
102731     }
102732   }
102733   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102734
102735   return jresult;
102736 }
102737
102738
102739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102740   void * jresult ;
102741   std::string *arg1 = 0 ;
102742   Dali::ImageDimensions arg2 ;
102743   Dali::FittingMode::Type arg3 ;
102744   Dali::ImageDimensions *argp2 ;
102745   Dali::ImageDimensions result;
102746
102747   if (!jarg1) {
102748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102749     return 0;
102750   }
102751   std::string arg1_str(jarg1);
102752   arg1 = &arg1_str;
102753   argp2 = (Dali::ImageDimensions *)jarg2;
102754   if (!argp2) {
102755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102756     return 0;
102757   }
102758   arg2 = *argp2;
102759   arg3 = (Dali::FittingMode::Type)jarg3;
102760   {
102761     try {
102762       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102763     } catch (std::out_of_range& e) {
102764       {
102765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102766       };
102767     } catch (std::exception& e) {
102768       {
102769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102770       };
102771     } catch (...) {
102772       {
102773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102774       };
102775     }
102776   }
102777   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102778
102779   return jresult;
102780 }
102781
102782
102783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102784   void * jresult ;
102785   std::string *arg1 = 0 ;
102786   Dali::ImageDimensions arg2 ;
102787   Dali::ImageDimensions *argp2 ;
102788   Dali::ImageDimensions result;
102789
102790   if (!jarg1) {
102791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102792     return 0;
102793   }
102794   std::string arg1_str(jarg1);
102795   arg1 = &arg1_str;
102796   argp2 = (Dali::ImageDimensions *)jarg2;
102797   if (!argp2) {
102798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102799     return 0;
102800   }
102801   arg2 = *argp2;
102802   {
102803     try {
102804       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102805     } catch (std::out_of_range& e) {
102806       {
102807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102808       };
102809     } catch (std::exception& e) {
102810       {
102811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102812       };
102813     } catch (...) {
102814       {
102815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102816       };
102817     }
102818   }
102819   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102820
102821   return jresult;
102822 }
102823
102824
102825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102826   void * jresult ;
102827   std::string *arg1 = 0 ;
102828   Dali::ImageDimensions result;
102829
102830   if (!jarg1) {
102831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102832     return 0;
102833   }
102834   std::string arg1_str(jarg1);
102835   arg1 = &arg1_str;
102836   {
102837     try {
102838       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102839     } catch (std::out_of_range& e) {
102840       {
102841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102842       };
102843     } catch (std::exception& e) {
102844       {
102845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102846       };
102847     } catch (...) {
102848       {
102849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102850       };
102851     }
102852   }
102853   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102854
102855   return jresult;
102856 }
102857
102858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102859   void * jresult ;
102860   std::string *arg1 = 0 ;
102861   Dali::ImageDimensions result;
102862
102863   if (!jarg1) {
102864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102865     return 0;
102866   }
102867   std::string arg1_str(jarg1);
102868   arg1 = &arg1_str;
102869   {
102870     try {
102871       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102872     } catch (std::out_of_range& e) {
102873       {
102874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102875       };
102876     } catch (std::exception& e) {
102877       {
102878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102879       };
102880     } catch (...) {
102881       {
102882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102883       };
102884     }
102885   }
102886   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102887
102888   return jresult;
102889 }
102890
102891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102892   void * jresult ;
102893   std::string *arg1 = 0 ;
102894   Dali::ImageDimensions arg2 ;
102895   Dali::FittingMode::Type arg3 ;
102896   Dali::SamplingMode::Type arg4 ;
102897   bool arg5 ;
102898   Dali::ImageDimensions *argp2 ;
102899   Dali::Devel::PixelBuffer result;
102900
102901   if (!jarg1) {
102902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102903     return 0;
102904   }
102905   std::string arg1_str(jarg1);
102906   arg1 = &arg1_str;
102907   argp2 = (Dali::ImageDimensions *)jarg2;
102908   if (!argp2) {
102909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102910     return 0;
102911   }
102912   arg2 = *argp2;
102913   arg3 = (Dali::FittingMode::Type)jarg3;
102914   arg4 = (Dali::SamplingMode::Type)jarg4;
102915   arg5 = jarg5 ? true : false;
102916   {
102917     try {
102918       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102919     } catch (std::out_of_range& e) {
102920       {
102921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102922       };
102923     } catch (std::exception& e) {
102924       {
102925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102926       };
102927     } catch (...) {
102928       {
102929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102930       };
102931     }
102932   }
102933   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102934
102935   return jresult;
102936 }
102937
102938
102939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102940   void * jresult ;
102941   std::string *arg1 = 0 ;
102942   Dali::ImageDimensions arg2 ;
102943   Dali::FittingMode::Type arg3 ;
102944   Dali::SamplingMode::Type arg4 ;
102945   Dali::ImageDimensions *argp2 ;
102946   Dali::Devel::PixelBuffer result;
102947
102948   if (!jarg1) {
102949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102950     return 0;
102951   }
102952   std::string arg1_str(jarg1);
102953   arg1 = &arg1_str;
102954   argp2 = (Dali::ImageDimensions *)jarg2;
102955   if (!argp2) {
102956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102957     return 0;
102958   }
102959   arg2 = *argp2;
102960   arg3 = (Dali::FittingMode::Type)jarg3;
102961   arg4 = (Dali::SamplingMode::Type)jarg4;
102962   {
102963     try {
102964       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102965     } catch (std::out_of_range& e) {
102966       {
102967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102968       };
102969     } catch (std::exception& e) {
102970       {
102971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102972       };
102973     } catch (...) {
102974       {
102975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102976       };
102977     }
102978   }
102979   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102980
102981   return jresult;
102982 }
102983
102984
102985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102986   void * jresult ;
102987   std::string *arg1 = 0 ;
102988   Dali::ImageDimensions arg2 ;
102989   Dali::FittingMode::Type arg3 ;
102990   Dali::ImageDimensions *argp2 ;
102991   Dali::Devel::PixelBuffer result;
102992
102993   if (!jarg1) {
102994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102995     return 0;
102996   }
102997   std::string arg1_str(jarg1);
102998   arg1 = &arg1_str;
102999   argp2 = (Dali::ImageDimensions *)jarg2;
103000   if (!argp2) {
103001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103002     return 0;
103003   }
103004   arg2 = *argp2;
103005   arg3 = (Dali::FittingMode::Type)jarg3;
103006   {
103007     try {
103008       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103009     } catch (std::out_of_range& e) {
103010       {
103011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103012       };
103013     } catch (std::exception& e) {
103014       {
103015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103016       };
103017     } catch (...) {
103018       {
103019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103020       };
103021     }
103022   }
103023   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103024
103025   return jresult;
103026 }
103027
103028
103029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103030   void * jresult ;
103031   std::string *arg1 = 0 ;
103032   Dali::ImageDimensions arg2 ;
103033   Dali::ImageDimensions *argp2 ;
103034   Dali::Devel::PixelBuffer result;
103035
103036   if (!jarg1) {
103037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103038     return 0;
103039   }
103040   std::string arg1_str(jarg1);
103041   arg1 = &arg1_str;
103042   argp2 = (Dali::ImageDimensions *)jarg2;
103043   if (!argp2) {
103044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103045     return 0;
103046   }
103047   arg2 = *argp2;
103048   {
103049     try {
103050       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103051     } catch (std::out_of_range& e) {
103052       {
103053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103054       };
103055     } catch (std::exception& e) {
103056       {
103057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103058       };
103059     } catch (...) {
103060       {
103061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103062       };
103063     }
103064   }
103065   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103066
103067   return jresult;
103068 }
103069
103070
103071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103072   void * jresult ;
103073   std::string *arg1 = 0 ;
103074   Dali::Devel::PixelBuffer result;
103075
103076   if (!jarg1) {
103077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103078     return 0;
103079   }
103080   std::string arg1_str(jarg1);
103081   arg1 = &arg1_str;
103082   {
103083     try {
103084       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103085     } catch (std::out_of_range& e) {
103086       {
103087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103088       };
103089     } catch (std::exception& e) {
103090       {
103091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103092       };
103093     } catch (...) {
103094       {
103095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103096       };
103097     }
103098   }
103099   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103100
103101   return jresult;
103102 }
103103
103104
103105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
103106   void * jresult ;
103107   Dali::Toolkit::WebView result;
103108
103109   {
103110     try {
103111       result = Dali::Toolkit::WebView::New();
103112     } catch (std::out_of_range& e) {
103113       {
103114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103115       };
103116     } catch (std::exception& e) {
103117       {
103118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103119       };
103120     } catch (Dali::DaliException e) {
103121       {
103122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103123       };
103124     } catch (...) {
103125       {
103126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103127       };
103128     }
103129   }
103130   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103131   return jresult;
103132 }
103133
103134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
103135   void * jresult ;
103136   Dali::Toolkit::WebView result;
103137
103138   std::string *arg1;
103139   std::string *arg2;
103140
103141   if (!jarg1) {
103142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
103143     return 0;
103144   }
103145   if (!jarg2) {
103146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
103147     return 0;
103148   }
103149
103150   std::string jarg1_str = std::string(jarg1);
103151   std::string jarg2_str = std::string(jarg2);
103152
103153   arg1 = &jarg1_str;
103154   arg2 = &jarg2_str;
103155
103156   {
103157     try {
103158       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
103159     } catch (std::out_of_range& e) {
103160       {
103161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103162       };
103163     } catch (std::exception& e) {
103164       {
103165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103166       };
103167     } catch (Dali::DaliException e) {
103168       {
103169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103170       };
103171     } catch (...) {
103172       {
103173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103174       };
103175     }
103176   }
103177   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103178   return jresult;
103179 }
103180
103181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103182   void * jresult ;
103183   Dali::Toolkit::WebView *arg1 = 0 ;
103184   Dali::Toolkit::WebView *result = 0 ;
103185
103186   arg1 = (Dali::Toolkit::WebView *)jarg1;
103187   if (!arg1) {
103188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103189     return 0;
103190   }
103191   {
103192     try {
103193       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103194     } catch (std::out_of_range& e) {
103195       {
103196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103197       };
103198     } catch (std::exception& e) {
103199       {
103200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103201       };
103202     } catch (Dali::DaliException e) {
103203       {
103204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103205       };
103206     } catch (...) {
103207       {
103208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103209       };
103210     }
103211   }
103212   jresult = (void *)result;
103213   return jresult;
103214 }
103215
103216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103217   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103218   arg1 = (Dali::Toolkit::WebView *)jarg1;
103219   {
103220     try {
103221       delete arg1;
103222     } catch (std::out_of_range& e) {
103223       {
103224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103225       };
103226     } catch (std::exception& e) {
103227       {
103228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103229       };
103230     } catch (Dali::DaliException e) {
103231       {
103232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103233       };
103234     } catch (...) {
103235       {
103236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103237       };
103238     }
103239   }
103240 }
103241
103242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103243   void * jresult ;
103244   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103245   Dali::Toolkit::WebView *arg2 = 0 ;
103246   Dali::Toolkit::WebView *result = 0 ;
103247
103248   arg1 = (Dali::Toolkit::WebView *)jarg1;
103249   arg2 = (Dali::Toolkit::WebView *)jarg2;
103250   if (!arg2) {
103251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103252     return 0;
103253   }
103254   {
103255     try {
103256       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103257     } catch (std::out_of_range& e) {
103258       {
103259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103260       };
103261     } catch (std::exception& e) {
103262       {
103263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103264       };
103265     } catch (Dali::DaliException e) {
103266       {
103267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103268       };
103269     } catch (...) {
103270       {
103271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103272       };
103273     }
103274   }
103275   jresult = (void *)result;
103276   return jresult;
103277 }
103278
103279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103280   void * jresult ;
103281   Dali::BaseHandle arg1 ;
103282   Dali::BaseHandle *argp1 ;
103283   Dali::Toolkit::WebView result;
103284
103285   argp1 = (Dali::BaseHandle *)jarg1;
103286   if (!argp1) {
103287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103288     return 0;
103289   }
103290   arg1 = *argp1;
103291   {
103292     try {
103293       result = Dali::Toolkit::WebView::DownCast(arg1);
103294     } catch (std::out_of_range& e) {
103295       {
103296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103297       };
103298     } catch (std::exception& e) {
103299       {
103300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103301       };
103302     } catch (Dali::DaliException e) {
103303       {
103304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103305       };
103306     } catch (...) {
103307       {
103308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103309       };
103310     }
103311   }
103312   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103313   return jresult;
103314 }
103315
103316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103317   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103318   std::string *arg2;
103319
103320   arg1 = (Dali::Toolkit::WebView *)jarg1;
103321
103322   if (!jarg2) {
103323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103324     return;
103325   }
103326
103327   std::string jarg2str = std::string(jarg2);
103328   arg2 = &jarg2str;
103329   {
103330     try {
103331       (arg1)->LoadUrl((std::string const &)*arg2);
103332     } catch (std::out_of_range& e) {
103333       {
103334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103335       };
103336     } catch (std::exception& e) {
103337       {
103338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103339       };
103340     } catch (Dali::DaliException e) {
103341       {
103342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103343       };
103344     } catch (...) {
103345       {
103346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103347       };
103348     }
103349   }
103350 }
103351
103352 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103353   char * jresult ;
103354   std::string result;
103355
103356   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103357
103358   arg1 = (Dali::Toolkit::WebView *)jarg1;
103359   {
103360     try {
103361       result = arg1->GetUrl();
103362     } catch (std::out_of_range& e) {
103363       {
103364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103365       };
103366     } catch (std::exception& e) {
103367       {
103368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103369       };
103370     } catch (Dali::DaliException e) {
103371       {
103372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103373       };
103374     } catch (...) {
103375       {
103376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103377       };
103378     }
103379   }
103380
103381   jresult = SWIG_csharp_string_callback((&result)->c_str());
103382   return jresult;
103383 }
103384
103385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103386   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103387   std::string *arg2;
103388
103389   arg1 = (Dali::Toolkit::WebView *)jarg1;
103390   if (!jarg2) {
103391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103392     return;
103393   }
103394   std::string jarg2str = std::string(jarg2);
103395   arg2 = &jarg2str;
103396   {
103397     try {
103398       (arg1)->LoadHTMLString((std::string const &)*arg2);
103399     } catch (std::out_of_range& e) {
103400       {
103401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103402       };
103403     } catch (std::exception& e) {
103404       {
103405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103406       };
103407     } catch (Dali::DaliException e) {
103408       {
103409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103410       };
103411     } catch (...) {
103412       {
103413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103414       };
103415     }
103416   }
103417 }
103418
103419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103420   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103421
103422   arg1 = (Dali::Toolkit::WebView *)jarg1;
103423   {
103424     try {
103425       (arg1)->Reload();
103426     } catch (std::out_of_range& e) {
103427       {
103428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103429       };
103430     } catch (std::exception& e) {
103431       {
103432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103433       };
103434     } catch (Dali::DaliException e) {
103435       {
103436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103437       };
103438     } catch (...) {
103439       {
103440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103441       };
103442     }
103443   }
103444 }
103445
103446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103447   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103448
103449   arg1 = (Dali::Toolkit::WebView *)jarg1;
103450   {
103451     try {
103452       (arg1)->StopLoading();
103453     } catch (std::out_of_range& e) {
103454       {
103455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103456       };
103457     } catch (std::exception& e) {
103458       {
103459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103460       };
103461     } catch (Dali::DaliException e) {
103462       {
103463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103464       };
103465     } catch (...) {
103466       {
103467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103468       };
103469     }
103470   }
103471 }
103472
103473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103474   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103475
103476   arg1 = (Dali::Toolkit::WebView *)jarg1;
103477   {
103478     try {
103479       (arg1)->GoBack();
103480     } catch (std::out_of_range& e) {
103481       {
103482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103483       };
103484     } catch (std::exception& e) {
103485       {
103486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103487       };
103488     } catch (Dali::DaliException e) {
103489       {
103490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103491       };
103492     } catch (...) {
103493       {
103494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103495       };
103496     }
103497   }
103498 }
103499
103500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103501   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103502
103503   arg1 = (Dali::Toolkit::WebView *)jarg1;
103504   {
103505     try {
103506       (arg1)->GoForward();
103507     } catch (std::out_of_range& e) {
103508       {
103509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103510       };
103511     } catch (std::exception& e) {
103512       {
103513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103514       };
103515     } catch (Dali::DaliException e) {
103516       {
103517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103518       };
103519     } catch (...) {
103520       {
103521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103522       };
103523     }
103524   }
103525 }
103526
103527 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103528   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103529   bool ret;
103530
103531   arg1 = (Dali::Toolkit::WebView *)jarg1;
103532   {
103533     try {
103534       ret = (arg1)->CanGoBack();
103535     } catch (std::out_of_range& e) {
103536       {
103537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103538       };
103539     } catch (std::exception& e) {
103540       {
103541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103542       };
103543     } catch (Dali::DaliException e) {
103544       {
103545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103546       };
103547     } catch (...) {
103548       {
103549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103550       };
103551     }
103552   }
103553   return ret;
103554 }
103555
103556 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103557   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103558   bool ret;
103559
103560   arg1 = (Dali::Toolkit::WebView *)jarg1;
103561   {
103562     try {
103563       ret = (arg1)->CanGoForward();
103564     } catch (std::out_of_range& e) {
103565       {
103566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103567       };
103568     } catch (std::exception& e) {
103569       {
103570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103571       };
103572     } catch (Dali::DaliException e) {
103573       {
103574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103575       };
103576     } catch (...) {
103577       {
103578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103579       };
103580     }
103581   }
103582   return ret;
103583 }
103584
103585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
103586   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103587   std::string *arg2;
103588
103589   arg1 = (Dali::Toolkit::WebView *)jarg1;
103590   if (!jarg2) {
103591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103592     return;
103593   }
103594   std::string jarg2_str = std::string(jarg2);
103595   arg2 = &jarg2_str;
103596   {
103597     try {
103598       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103599     } catch (std::out_of_range& e) {
103600       {
103601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103602       };
103603     } catch (std::exception& e) {
103604       {
103605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103606       };
103607     } catch (Dali::DaliException e) {
103608       {
103609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103610       };
103611     } catch (...) {
103612       {
103613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103614       };
103615     }
103616   }
103617 }
103618
103619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103620 {
103621   if (!jarg2) {
103622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103623     return;
103624   }
103625
103626   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103627   std::string exposedObjectName = jarg2;
103628   void (*handler)(char*) = (void (*)(char*)) jarg3;
103629
103630   {
103631     try {
103632       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103633         handler(SWIG_csharp_string_callback(message.c_str()));
103634       });
103635     } catch (std::out_of_range& e) {
103636       {
103637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103638       };
103639     } catch (std::exception& e) {
103640       {
103641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103642       };
103643     } catch (Dali::DaliException e) {
103644       {
103645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103646       };
103647     } catch (...) {
103648       {
103649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103650       };
103651     }
103652   }
103653 }
103654
103655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103656   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103657
103658   arg1 = (Dali::Toolkit::WebView *)jarg1;
103659   {
103660     try {
103661       (arg1)->ClearHistory();
103662     } catch (std::out_of_range& e) {
103663       {
103664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103665       };
103666     } catch (std::exception& e) {
103667       {
103668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103669       };
103670     } catch (Dali::DaliException e) {
103671       {
103672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103673       };
103674     } catch (...) {
103675       {
103676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103677       };
103678     }
103679   }
103680 }
103681
103682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103683   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103684
103685   arg1 = (Dali::Toolkit::WebView *)jarg1;
103686   {
103687     try {
103688       (arg1)->ClearCache();
103689     } catch (std::out_of_range& e) {
103690       {
103691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103692       };
103693     } catch (std::exception& e) {
103694       {
103695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103696       };
103697     } catch (Dali::DaliException e) {
103698       {
103699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103700       };
103701     } catch (...) {
103702       {
103703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103704       };
103705     }
103706   }
103707 }
103708
103709 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103710     return (Dali::Toolkit::Control *)jarg1;
103711 }
103712
103713
103714 // Proxy class of WebViewSignal.
103715 // WebViewSignal has an argument of std::string type which is not supported at C# side.
103716 // The purpose of this class is to convert signal argument of string type safely.
103717 class WebViewSignalProxy : public ConnectionTracker
103718 {
103719 public:
103720   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
103721   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
103722   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
103723
103724   WebViewSignalProxy(OriginalSignalType* signal)
103725     : mSignalPtr(signal)
103726   {
103727   }
103728
103729   void Connect(CallbackType csharpCallback)
103730   {
103731     if (mSignalPtr->Empty())
103732     {
103733       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
103734     }
103735     mProxySignal.Connect(csharpCallback);
103736   }
103737
103738   void Disconnect(CallbackType csharpCallback)
103739   {
103740     mProxySignal.Disconnect(csharpCallback);
103741     if (mProxySignal.Empty())
103742     {
103743       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
103744     }
103745   }
103746
103747   bool Empty()
103748   {
103749     return mProxySignal.Empty();
103750   }
103751
103752   std::size_t GetConnectionCount()
103753   {
103754     return mProxySignal.GetConnectionCount();
103755   }
103756
103757   void Emit(Dali::Toolkit::WebView& webview, char* url)
103758   {
103759     if (!mProxySignal.Empty())
103760     {
103761       mProxySignal.Emit(webview, url);
103762     }
103763   }
103764
103765   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
103766   {
103767     // Safe string conversion
103768     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
103769   }
103770
103771 private:
103772   OriginalSignalType* mSignalPtr;
103773   ProxySignalType mProxySignal;
103774 };
103775
103776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
103777   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103778   WebViewSignalProxy* result = NULL;
103779   {
103780     try {
103781       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
103782     } catch (std::out_of_range& e) {
103783       {
103784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103785       };
103786     } catch (std::exception& e) {
103787       {
103788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103789       };
103790     } catch (Dali::DaliException e) {
103791       {
103792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103793       };
103794     } catch (...) {
103795       {
103796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103797       };
103798     }
103799   }
103800   return (void*) result;
103801 }
103802
103803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
103804   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103805   WebViewSignalProxy* result = NULL;
103806   {
103807     try {
103808       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
103809     } catch (std::out_of_range& e) {
103810       {
103811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103812       };
103813     } catch (std::exception& e) {
103814       {
103815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103816       };
103817     } catch (Dali::DaliException e) {
103818       {
103819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103820       };
103821     } catch (...) {
103822       {
103823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103824       };
103825     }
103826   }
103827   return (void*) result;
103828 }
103829
103830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
103831 {
103832   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
103833   {
103834     try {
103835       delete object;
103836     } catch (std::out_of_range& e) {
103837       {
103838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103839       };
103840     } catch (std::exception& e) {
103841       {
103842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103843       };
103844     } catch (Dali::DaliException e) {
103845       {
103846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103847       };
103848     } catch (...) {
103849       {
103850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103851       };
103852     }
103853   }
103854 }
103855
103856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
103857 {
103858   bool result;
103859   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103860   {
103861     try {
103862       result = (bool)proxy->Empty();
103863     } catch (std::out_of_range& e) {
103864       {
103865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103866       };
103867     } catch (std::exception& e) {
103868       {
103869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103870       };
103871     } catch (Dali::DaliException e) {
103872       {
103873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103874       };
103875     } catch (...) {
103876       {
103877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103878       };
103879     }
103880   }
103881   return (unsigned int) result;
103882 }
103883
103884
103885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
103886 {
103887   std::size_t result;
103888   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
103889   {
103890     try {
103891       result = arg1->GetConnectionCount();
103892     } catch (std::out_of_range& e) {
103893       {
103894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103895       };
103896     } catch (std::exception& e) {
103897       {
103898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103899       };
103900     } catch (Dali::DaliException e) {
103901       {
103902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103903       };
103904     } catch (...) {
103905       {
103906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103907       };
103908     }
103909   }
103910   return (unsigned long) result;
103911 }
103912
103913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
103914 {
103915   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103916   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
103917   {
103918     try {
103919       proxy->Connect(callback);
103920     } catch (std::out_of_range& e) {
103921       {
103922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103923       };
103924     } catch (std::exception& e) {
103925       {
103926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103927       };
103928     } catch (Dali::DaliException e) {
103929       {
103930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103931       };
103932     } catch (...) {
103933       {
103934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103935       };
103936     }
103937   }
103938 }
103939
103940
103941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
103942   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103943   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
103944   {
103945     try {
103946       proxy->Disconnect(callback);
103947     } catch (std::out_of_range& e) {
103948       {
103949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103950       };
103951     } catch (std::exception& e) {
103952       {
103953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103954       };
103955     } catch (Dali::DaliException e) {
103956       {
103957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103958       };
103959     } catch (...) {
103960       {
103961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103962       };
103963     }
103964   }
103965 }
103966
103967
103968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
103969   if (!jarg2) {
103970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
103971     return ;
103972   }
103973   if (!jarg3) {
103974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
103975     return ;
103976   }
103977
103978   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103979   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
103980   {
103981     try {
103982       proxy->Emit(*webview, jarg3);
103983     } catch (std::out_of_range& e) {
103984       {
103985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103986       };
103987     } catch (std::exception& e) {
103988       {
103989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103990       };
103991     } catch (Dali::DaliException e) {
103992       {
103993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103994       };
103995     } catch (...) {
103996       {
103997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103998       };
103999     }
104000   }
104001 }
104002
104003 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
104004   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
104005   char * jresult = SWIG_csharp_string_callback((const char *)result);
104006   return jresult;
104007 }
104008
104009 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
104010   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
104011   return result;
104012 }
104013
104014 #ifdef __cplusplus
104015 }
104016 #endif
104017